text
stringlengths 20
1.01M
| url
stringlengths 14
1.25k
| dump
stringlengths 9
15
⌀ | lang
stringclasses 4
values | source
stringclasses 4
values |
|---|---|---|---|---|
newoperator syntax, and can have properties assigned to them dynamically. Objects can also be created by assigning an object literal, as in:
var obj:Object = {a:"foo", b:"bar"}
All classes that don't declare an explicit base class extend the built-in Object class.
You can use the Object class to create associative arrays.
ActionScript 3.0 has two types of inheritance: class inheritance and prototype inheritance:
Both class inheritance and prototype inheritance can exist simultaneously, as shown in the following example:
class A { var x = 1 prototype.px = 2 } dynamic class B extends A { var y = 3 prototype.py = 4 } var b = new B() b.x // 1 via class inheritance b.px // 2 via prototype inheritance from A.prototype b.y // 3 b.py // 4 via prototype inheritance from B.prototype B.prototype.px = 5 b.px // now 5 because B.prototype hides A.prototype b.px = 6 b.px // now 6 because b hides B.prototype
Using functions instead of classes, you can construct custom prototype inheritance trees. With classes, the prototype inheritance tree mirrors the class inheritance tree. However, since the prototype objects are dynamic, you can add and delete prototype-based properties at run time.
See also
public var constructor:Object
A reference to the class object or constructor function for a given object instance.
If an object is an instance of a class, the
constructor
property holds a reference to the class object.
If an object is created with a constructor function, the
constructor
property holds a reference to the constructor function.
Do not confuse a constructor function with a constructor method of a class.
A constructor function is a Function object used to create objects, and is an
alternative to using the
class keyword for defining classes.
If you use the
class keyword to define a class, the class's prototype object
is assigned a property named
constructor that holds a reference to the class object.
An instance of the class inherits this property from the prototype object. For example,
the following code creates a new class,
A, and a class instance named
myA:
dynamic class A {} trace(A.prototype.constructor); // [class A] trace(A.prototype.constructor == A); // true var myA:A = new A(); trace(myA.constructor == A); // true
Advanced users may choose to use the
function keyword instead of the
class
keyword to define a Function object that can be used as a template for creating objects. Such a
function is called a constructor function because you can use it in conjunction with the
new
operator to create objects.
If you use the
function keyword to create a constructor function, its prototype object is assigned
a property named
constructor that holds a reference to the constructor function.
If you then use the constructor function to create an object, the object inherits the
constructor property from the constructor function's prototype object. For example,
the following code creates a new constructor function,
f, and an object named
myF:
function f() {} trace(f.prototype.constructor); // function Function() {} trace(f.prototype.constructor == f); // true var myF = new f(); trace(myF.constructor == f); // true
Note: The
constructor property is writable, which means that user code can change
its value with an assignment statement. Changing the value of the
constructor property is not
recommended, but if you write code that depends on the value of the
constructor property, you should
ensure that the value is not reset. The value can be changed only when the property is accessed through the prototype
object (for example,
className.prototype.constructor).
See also
public static var prototype:Object
A reference to the prototype object of a class or function object. The
prototype property
is automatically created and attached to any class or function object that you create. This property is
static in that it is specific to the class or function that you create. For example, if you create a
class, the value of the
prototype property is shared by all instances of the class and is
accessible only as a class property. Instances of your class cannot directly access
the
prototype property.
A class's prototype object is a special instance of that class that provides a mechanism for sharing state across all instances of a class. At run time, when a property is not found on a class instance, the delegate, which is the class prototype object, is checked for that property. If the prototype object does not contain the property, the process continues with the prototype object's delegate checking in consecutively higher levels in the hierarchy until Flash Player finds the property.
Note: In ActionScript 3.0, prototype inheritance is not the primary mechanism for inheritance. Class inheritance, which drives the inheritance of fixed properties in class definitions, is the primary inheritance mechanism in ActionScript 3.0.
See also
public function Object()
Creates an Object object and stores a reference to the object's constructor method in the object's
constructor property.
See also
AS3 function hasOwnProperty(name:String):Boolean
Indicates whether an object has a specified property defined. This method returns
true if the target object has
a property that matches the string specified by the
name parameter, and
false otherwise.
The following types of properties cause this method to return
true for objects that are instances of a class (as opposed to class objects):
dynamickeyword.
The following types of properties cause this method to return
false for objects that are instances of a class:
valueOf()method because it exists on
Object.prototype, which is part of the prototype chain for the Array class. Although you can use
valueOf()on an instance of Array, the return value of
hasOwnProperty("valueOf")for that instance is
false.
ActionScript 3.0 also has class objects, which are direct representations of class definitions.
When called on class objects, the
hasOwnProperty() method returns
true only if a property
is a static property defined on that class object. For example, if you create a subclass of Array named
CustomArray, and define a static property in CustomArray named
foo, a call to
CustomArray.hasOwnProperty("foo") returns
true.
For the static property
DESCENDING defined in the Array class, however, a call to
CustomArray.hasOwnProperty("DESCENDING") returns
false.
Note: Methods of the Object class are dynamically created on Object's prototype. To redefine this method in a subclass of Object, do not use the
override keyword. For example, A subclass of Object implements
function hasOwnProperty():Boolean instead of using an override of the base class.
AS3 function isPrototypeOf(theClass:Object):Boolean
Indicates whether an instance of the Object class is in the prototype chain of the object specified
as the parameter. This method returns
true if the object is in the prototype chain of the
object specified by the
theClass parameter. The method returns
false
if the target object is absent from the prototype chain of the
theClass object,
and also if the
theClass parameter is not an object.
Note: Methods of the Object class are dynamically created on Object's prototype. To redefine this method in a subclass of Object, do not use the
override keyword. For example, A subclass of Object implements
function isPrototypeOf():Boolean instead of using an override of the base class.
AS3 function propertyIsEnumerable(name:String):Boolean
Indicates whether the specified property exists and is enumerable. If
true, then the property exists and
can be enumerated in a
for..in loop. The property must exist on the target object because this method does not
check the target object's prototype chain.
Properties that you create are enumerable, but built-in properties are generally not enumerable.
Note: Methods of the Object class are dynamically created on Object's prototype. To redefine this method in a subclass of Object, do not use the
override keyword. For example, A subclass of Object implements
function propertyIsEnumerable():Boolean instead of using an override of the base class.
public function setPropertyIsEnumerable(name:String, isEnum:Boolean = true):void
Sets the availability of a dynamic property for loop operations. The property must exist on the target object because this method does not check the target object's prototype chain.Parameters.
public function valueOf():Object
Returns the primitive value of the specified object. If this object does not have a primitive value, the object itself is returned.
Note: Methods of the Object class are dynamically created on Object's prototype. To redefine this method in a subclass of Object, do not use the
override keyword. For example, A subclass of Object implements
function valueOf():Object instead of using an override of the base class.
See also
ObjectExampleand
Circleto demonstrate the dynamic nature of the Object class, and how value objects can be transformed into Shape objects and then added to the stage at the specified x/y coordinates.
The example creates the value objects
firstInitObj and
secondInitObj. The custom
class
Circle accepts the value object and loops over it while setting its matching internal
properties to those defined in the value object.
package { import flash.display.Sprite; public class ObjectExample extends Sprite { public function ObjectExample() { var firstInitObj:Object = new Object(); firstInitObj.bgColor = 0xFF0000; firstInitObj.radius = 25; firstInitObj.xCenter = 25; firstInitObj.yCenter = 25; var firstCircle:Circle = new Circle(firstInitObj); addChild(firstCircle); firstCircle.x = 50; firstCircle.y = 50; var secondInitObj:Object = {bgColor:0xCCCCCC, radius:50, xCenter:50, yCenter:50}; var secondCircle:Circle = new Circle(secondInitObj); addChild(secondCircle); secondCircle.x = 100; secondCircle.y = 100; } } } import flash.display.Shape; class Circle extends Shape { public var bgColor:Number = 0xFFFFFF; public var radius:Number = 0; public var xCenter:Number = 0; public var yCenter:Number = 0; public function Circle(initObj:Object) { for(var i:String in initObj) { this[i] = initObj[i]; } draw(); } public function draw():void { graphics.beginFill(bgColor); graphics.drawCircle(xCenter, yCenter, radius); graphics.endFill(); } } | http://www.adobe.com/livedocs/flex/201/langref/Object.html | crawl-002 | en | refinedweb |
JavaScript Editor
JavaScript
Flex
IntelliJ IDEA features excellent JavaScript editor for productive JavaScript programming. All of its features including code completion, error highlighting and refactoring, quick fixes and intention actions are JavaScript aware and let you productively create efficient JavaScript code.
JavaScript
Debuggers for JavaScript and Flex
IntelliJ IDEA's debugger now supports JavaScript and Flex debugging with a complete range of features — watches, conditional breakpoints, dependent breakpoints, expression evaluation and more.
JavaScript Debugger live demo
- Breakpoints in HTML, JavaScript/ActionScript and JSP/MXML files
- Customizable breakpoint properties: suspend mode, conditions, pass count and more
- Frames, variables and watches views
- Runtime evaluation of JavaScript expressions
Extended frameworks
- JSON supported, with coding assistance
- JSDoc and DoJo style type annotations support for improved code completion and parameter type information
- Quick documentation lookup for for JSDoc and DoJo style comments
- JavaScript namespaces support in code completion and inspections
JavaScript code completion
IntelliJ IDEA completes keywords, labels, variables, parameters and functions, including completion in HTML event handlers.
Completion works fine for both user defined and built-in JavaScript functions.
New in version 6.0, JavaScript completion is DOM-based and browser-aware, which is helpful for developing scripts that are intended to run under multiple browsers.
Since version 6.0 the code completion has also been enhanced with the support for the most popular
JavaScript frameworks like Dojo, Prototype and Bindows.
JavaScript error & syntax highlighting
IntelliJ IDEA is capable of highlighting JavaScript errors on-the-fly to hunt them far before your application produces an error.
Advanced syntax highlighting works fine both in standalone JavaScript (JS files) and embedded HTML JavaScript code.
JavaScript refactoring
The full range of IntelliJ IDEA refactorings supports the JavaScript code. Rename file, function, variable, parameter, or label (both directly and via references, even within HTML):
Rename file, function, variable, parameter, or label (both directly and via references, even within HTML):
Move/Copy file: you can easily move a .js file to another directory, by simply pressing F6 and specifying its new location. All references to the file throughout your project will be automatically resolved.
Safe Delete file: in case you are trying to delete a .js file that referenced in other project files, IntelliJ IDEA will notify you about that, giving you an opportunity to either resolve the inconsistency first, or just cancel the operation.
.
JavaScript code formatting
Formatting for JavaScript code is supported through customizable settings. This allows to follow almost any coding guide-lines that concern code styles. Formatting options for JavaScript are actually inherited from those for Java and are shareable.
JavaScript code folding
To make your code view more clear to read and understand, IntelliJ IDEA lets you fold certain parts of it. The Code Folding feature collapses blocks of code with a single shortcut (Ctrl + NumPad +). The folded code can be quickly seen in a popup by positioning the cursor over the grayed dots.
Surrounding JavaScript code blocks with common constructs
The Surround With command (Ctrl + Alt + T) can be called on a selected block of JavaScript code, for quickly inserting it into a surrounding construct, like expression parentheses, if/else block, etc.
Advanced JavaScript Search and Navigation
IntelliJ IDEA symbol
You can use the (Ctrl + Alt + Shift + N) shortcut to navigate through symbols declared in your JavaScript code.
Different search patterns are supported, including use of asterisk (*) and CamelHump abbreviations.
Goto declaration
Navigation to a declaration lets you browse through the functions, variables and labels declared in your JavaScript code. Use the Ctrl + Click combination, or position the caret at a symbol usage and press Ctrl + B. This will immediately navigate you to the line of code where the label is declared.
JavaScript structure view
IntelliJ IDEA lets you examine the logical structure of your JavaScript code. The Autoscroll to Source and Autoscroll from Source toolbar buttons keep you synchronized with the editor.
Flex
Flex-ready intention actions
- implement/override methods
- generate accessors and constructors
- auto-import
- Imports optimization
IntelliJ IDEA supports Flex through the dedicated Flex Facet and provides the advanced coding assistance for ActionScript 4, MXML (with embedded JavaScript), with code completion, syntax and error highlighting with quick-fixes and refactorings, smart navigation, annotations, plus the quick documentation lookup from Flex SDK to help you productively develop Flex applications.
Flex Code Editing
IntelliJ IDEA ActionScript and MXML editor is beefed up with new features like implement/override methods, generate accessors and constructors, auto-import and optimize imports, etc. IntelliJ IDEA 8 also supports Flash 10 ActionScript generics.
- Automatic namespace import when you use a class or interface
- Alt+Ins automatically generates the following code:
- Implemented methods
- Overriden methods
- Getters and setters for properties
Flex-aware smart code completion
IntelliJ IDEA Flex coding assistance recognizes Flash 10 generics.
Flex code syntax highlighting and formatting
Flex-ready on-the-fly code inspections with instant quick-fixes
Go to symbol, declaration and usage features are also Flex-aware
Flex-ready code refactorings
IntelliJ IDEA features the basic set of refactorings to transform and upgrade your Flex code.
- Copy
- Move
- Safe delete
- Introduce variable
- Migrate
Advanced Flex-aware code structure view
| http://www.jetbrains.com/idea/features/javascript_editor.html | crawl-002 | en | refinedweb |
Web Age Solutions Inc.
At the time of this writing (Aug 2006), Glassfish has the most complete implementation of Java EE 5, including EJB 3. This tutorial shows how to install Glassfish from scratch and then develop and test a simple Session EJB using Eclipse. This is meant for developers who will like to learn EJB 3 right now, before any commercial development IDE becomes available.
First download Glassfish from Here. Download a milestone build for maximum stability. This tutorial was developed using V1 Milestone 7. It is recommended that to follow this tutorial you use a V1 build rather than V2 (which may behave slightly differently).
Glassfish will be downloaded as a JAR file (such as glassfish-installer-9.0-b48.jar).
First install Sun JDK 1.5 (also called J2SE 5). Installation of this is very simple and beyond the scope of this article.
Open a command window.
Set the JAVA_HOME variable to point to the root installation folder of JDK. For example:
set JAVA_HOME=c:\jdk15
Copy the Glassfish JAR file to C:\.
Begin installation of Glassfish, by entering the following command from C:\.
java -Xmx256M -jar glassfish-installer-XXXX.jar
System will open a license window.
Scroll down and click on Accept.
System will extract all the files in C:\glassfish.
In the command window, change directory to that folder.
cd c:\glassfish
To complete the setup, run this command:
lib\ant\bin\ant -f setup.xml
Make sure that the command ends with a BUILD SUCCESSFUL message. Congratulations, the installation is now complete.
First, we will start the Derby database server. This is really not necessary for this tutorial. But, it is a good idea to run the database if you will do more advanced EJB development (such as timers and entity persistence).
In the command prompt, change directory to C:\glassfish\bin folder. Then, enter the command:
asadmin start-database
After the database starts, run the application server.
asadmin start-domain
We will verify the installation by logging into the administration console. Open a new browser window and enter the URL.
Login using the user ID admin and password adminadmin. This will validate the installation.
We will assume that you already have a fully functional Eclipse 3.2 installation. Launch Eclipse. We will create two Java projects:
First, create a new Java project called Simple EJB Project.
Now, we will add two JAR files from Glassfish to the compiler's classpath. Open the properties dialog of the project. Then select the Java Build Path property. Click on the Libraries tab. Click on Add External JARs.
Navigate to the C:\glassfish\lib folder and select appserv-rt.jar and javaee.jar. Click on Open.
Make sure that the two JAR files are added to the compiler's class path. Click on OK to close the properties dialog. Note: You can export this Java project as an archive file and easily import it later for quickly creating a new Glassfish EJB project.
Now, we will create the client project called Simple Client Project. Quickest way to create this project is to copy the Simple EJB Project and paste it as Simple Client Project. Alternatively, you can create a new Java project and add the two JAR files to the build path as shown above.
The client project needs to refer to the remote or local interfaces of the EJBs. The simplest way to set this up is to set a dependency between the client and EJB projects. In real life, the client may be developed by a different team than the EJB and the client developers may not have access to the EJB project. In this case, the EJB developers need to export a client JAR file and hand it to the client developers. We will keep things simple, and have the client project refer to the EJB project.
Open the Properties dialog of the Simple Client Project. Select the Java Build Path property. Click on the Projects tab. Click on Add. Select the check box next to Simple EJB Project. Click on OK.
Click on OK to accept the changes.
In the Simple EJB Project, create a new package called com.webage.ejbs. First, we will create the remote interface for the EJB. In the package you have just created, create a new Java interface called SimpleBean. Add the following code:
import javax.ejb.*;
@Remote
public interface SimpleBean {
public String sayHello(String name);
}
Note: The @Remote annotation marks this interface as a remote interface. This annotation belongs to the javax.ejb package. Hence, we had imported the package in the file. Alternatively, you could use the annotation @javax.ejb.Remote.
Save and close this file.
Now, we will create the bean class. In the same package, create a new Java class called SimpleBeanImpl. Add the following code.
import javax.ejb.*;
@Stateless(name="Example", mappedName="ejb/SimpleBeanJNDI")
public class SimpleBeanImpl implements SimpleBean {
public String sayHello(String name) {
return "Hello " + name + "!";
}
}
Note:
Save and close this file.
In the Simple Client Project, create a new package called com.webage.client. In this package, create a new class called TestClient. Add the following code:
import javax.naming.*;
import com.webage.ejbs.SimpleBean;
public class TestClient {
public void runTest() throws Exception {
InitialContext ctx = new InitialContext();
SimpleBean bean = (SimpleBean) ctx.lookup("ejb/SimpleBeanJNDI");
String result = bean.sayHello("Billy Bob");
System.out.println(result);
}
public static void main(String[] args) {
try {
TestClient cli = new TestClient();
cli.runTest();
} catch (Exception e) {
e.printStackTrace();
}
}
}
Note: We do a JNDI lookup of the name "ejb/SimpleBeanJNDI" as this has been configured as the JNDI name of the EJB. We can not use the dependency injection annotation @EJB to do the look up as our client will run outside of any Java EE container.
The rest of the code should be fairly straight forward. Save and close this file.
We will use the automatic deployment feature of Glassfish to rapidly deploy the EJB module. This option involves, simply dropping the EJB JAR file under the C:\glassfish\domains\domain1\autodeploy folder.
First, we will export the EJB JAR file. Right click on Simple EJB Project and select Export.
Expand Java and select JAR file. Click on Next.
In the JAR file text box, enter C:\glassfish\domains\domain1\autodeploy\test_ejb.jar.
Also, check the Overwrite existing files without warning option. This will speed up the export process in subsequent times.
Click on Finish to export the JAR file.
Glassfish will automatically install the EJB JAR file within a few seconds. It is a good idea to monitor the server's log file to be certain if the EJB JAR file was deployed successfully. Monitoring the log file will also help you detect problems with your EJB code as they occur at runtime. The log file is located at C:\glassfish\domains\domain1\logs\server.log. You can use a tool like PigTail to monitor the file.
Switch back to Eclipse.
In the Package Explorer view, right click on TestClient.java and select Run As->Java Application. Make sure that the Console view shows the following output.
During development, you will no doubt change the EJB code frequently. To re-deploy the EJB JAR file, simply export the EJB JAR file again following the process already mentioned.
From the C:\glassfish\bin folder, run these commands:
asadmin stop-database
asadmin stop-domain
In this tutorial, we have set up a development environment for Glassfish based EJB 3 development. We developed and tested a stateless session EJB. You can use this environment and approach to develop more complex EJBs, including entity persistence.
Feedback
Your e-mail:
Rate this article:
Very useful
Somewhat useful
Not bad
Needs many corrections | http://www.webagesolutions.com/knowledgebase/javakb/jkb005/index.html | crawl-002 | en | refinedweb |
When the Joint2D.reactionForce is higher than the Joint2D.breakForce or the Joint2D.reactionTorque is higher than the Joint2D.breakTorque of the joint, the joint will break.
When the joint breaks, OnJointBreak2D will be called and the specific Joint2D that broke will be passed in.
After OnJointBreak2D is called, the joint will automatically be removed from the game object and deleted.
See Also: Joint2D.breakForce, Joint2D.breakTorque, Joint2D.reactionForce y Joint2D.reactionTorque.
using UnityEngine; using System.Collections;
public class ExampleClass : MonoBehaviour { void OnJointBreak2D(Joint2D brokenJoint) { Debug.Log("A joint has just been broken!"); Debug.Log("The broken joint exerted a reaction force of " + brokenJoint.reactionForce); Debug.Log("The broken joint exerted a reaction torque of " + brokenJoint.reactionTorque); } } | https://docs.unity3d.com/es/2018.1/ScriptReference/MonoBehaviour.OnJointBreak2D.html | CC-MAIN-2019-47 | en | refinedweb |
Converting a sequence to a dictionary using the ToDictionary LINQ operator
August 10, 2017 Leave a comment
Say you have a sequence of objects that you’d like to convert into a Dictionary for efficient access by key. Ideally the objects have some kind of “natural” key for the dictionary such as an ID:
public class Singer { public int Id { get; set; } public string FirstName { get; set; } public string LastName { get; set; } } IEnumerable<Singer> singers ="} }; | https://dotnetcodr.com/category/linq/page/2/ | CC-MAIN-2019-47 | en | refinedweb |
Elixir v1.4 released
Elixir v1.4 brings new features, enhancements and bug fixes. The most notable changes are the addition of the
Registry module, the
Task.async_stream/3 and
Task.async_stream/5 function which aid developers in writing concurrent software, and the new application inference and commands added to Mix.
In this post we will cover the main additions. The complete release notes are also available.
Registry
The
Registry is a new module in Elixir’s standard library that allows Elixir developers to implement patterns such as name lookups, code dispatching or even a pubsub system in a simple and scalable way.
Broadly speaking, the Registry is a local, decentralized and scalable key-value process storage. Let’s break this in parts:
- Local because keys and values are only accessible to the current node (opposite to distributed)
- Decentralized because there is no single entity responsible for managing the registry
- Scalable because performance scales linearly with the addition of more cores upon partitioning
A registry may have unique or duplicate keys. Every key-value pair is associated to the process registering the key. Keys are automatically removed once the owner process terminates. Starting, registering and looking up keys is quite straight-forward:
iex> Registry.start_link(:unique, MyRegistry) iex> {:ok, _} = Registry.register(MyRegistry, "hello", 1) iex> Registry.lookup(MyRegistry, "hello") [{self(), 1}]
Finally, huge thanks to Bram Verburg who has performed extensive benchmarks on the registry to show it scales linearly with the number of cores by increasing the number of partitions.
Syntax coloring
Elixir v1.4 introduces the ability to syntax color inspected data structures and IEx automatically relies on this feature to provide syntax coloring for evaluated shell results:
This behaviour can be configured via the
:syntax_colors coloring option:
IEx.configure [colors: [syntax_colors: [atom: :cyan, string: :green]]]
To disable coloring altogether, simply pass an empty list to
:syntax_colors.
Task.async_stream
When there is a need to traverse a collection of items concurrently, Elixir developers often resort to tasks:
collection |> Enum.map(&Task.async(SomeMod, :function, [&1])) |> Enum.map(&Task.await/1)
The snippet above will spawn a new task by invoking
SomeMod.function(element) for every element in the collection and then await for the task results.
However, the snippet above will spawn and run concurrently as many tasks as there are items in the collection. While this may be fine in many occasions, including small collections, sometimes it is necessary to restrict amount of tasks running concurrently, specially when shared resources are involved.
Elixir v1.4 adds
Task.async_stream/3 and
Task.async_stream/5 which brings some of the lessons we learned from the GenStage project directly into Elixir:
collection |> Task.async_stream(SomeMod, :function, [], max_concurrency: 8) |> Enum.to_list()
The code above will also start the same
SomeMod.function(element) task for every element in the collection except it will also guarantee we have at most 8 tasks being processed at the same time. You can use
System.schedulers_online to retrieve the number of cores and balance the processing based on the amount of cores available.
The
Task.async_stream functions are also lazy, allowing developers to partially consume the stream until a condition is reached. Furthermore,
Task.Supervisor.async_stream/4 and
Task.Supervisor.async_stream/6 can be used to ensure the concurrent tasks are spawned under a given supervisor.
Application inference
In previous Mix versions, most of your dependencies had to be added both to your dependencies list and applications list. Here is how a
mix.exs would look like:
def application do [applications: [:logger, :plug, :postgrex]] end def deps do [{:plug, "~> 1.2"}, {:postgrex, "~> 1.0"}] end
This was a common source of confusion and quite error prone as many developers would not list their dependencies in the applications list.
Mix v1.4 now automatically infers your applications list as long as you leave the
:applications key empty. The
mix.exs above can be rewritten to:
def application do [extra_applications: [:logger]] end def deps do [{:plug, "~> 1.2"}, {:postgrex, "~> 1.0"}] end
With the above, Mix will automatically build your application list based on your dependencies. Developers now only need to specify which applications shipped as part of Erlang or Elixir that they require, such as
:logger.
Finally, if there is a dependency you don’t want to include in the application runtime list, you can do so by specifying the
runtime: false option:
{:distillery, "> 0.0.0", runtime: false}
We hope this feature provides a more streamlined workflow for developers who are building releases for their Elixir projects.
Mix install from SCM
Mix v1.4 can now install escripts and archives from both Git and Hex, providing you with even more options for distributing Elixir code.
This makes it possible to distribute CLI applications written in Elixir by publishing a package which builds an escript to Hex.
ex_doc has been updated to serve as an example of how to use this new functionality.
Simply running:
mix escript.install hex ex_doc
will fetch
ex_doc and its dependencies, build them, and then install
ex_doc to
~/.mix/escripts (by default). After adding
~/.mix/escripts to your
PATH, running
ex_doc is as simple as:
ex_doc
You can now also install archives from Hex in this way. Since they are fetched and built on the user’s machine, they do not have the same limitations as pre-built archives. However, keep in mind archives are loaded on every Mix command and may conflict with modules or dependencies in your projects. For this reason, escripts is the preferred format for sharing executables.
It is also possible to install escripts and archives by providing a Git/GitHub repo. See
mix help escript.install and
mix help archive.install for more details.
Summing up
The full list of changes is available in our release notes. Don’t forget to check the Install section to get Elixir installed and our Getting Started guide to learn more.
Happy coding! | https://elixir-lang.org/blog/2017/01/05/elixir-v1-4-0-released/ | CC-MAIN-2019-47 | en | refinedweb |
Subject: Re: [boost] [#pragma once]
From: Eugene Wee (crystalrecursion_at_[hidden])
Date: 2009-04-10 11:48:10
Hi,
On Fri, Apr 10, 2009 at 11:23 PM, Marcus Lindblom <macke_at_[hidden]> wrote:
> I've seen benchmarks that say some compilers (gcc, msvc) are smart enough to
> recognize #ifndef/#endif and do the #pragma once equivalent. (i.e. there's
> no discernable performance difference.)
Sutter and Alexandrescu say the same in C++ Coding Standards Item #24,
but with admonishment to keep all other code and comments in between
to cater for less intelligent detection of include guards (whereas
many header files in Boost have comments right at the top).
Regards,
Eugene Wee
Boost list run by bdawes at acm.org, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk | https://lists.boost.org/Archives/boost/2009/04/150654.php | CC-MAIN-2019-47 | en | refinedweb |
I would like to request that python 3.5 be set as the default 3,X version. It was released on 09/13/2015 and is apparently quite stable.
Thank You :)
I'll take this (as I requested the issue be created)
it should be given to portmgr for exp-run, why take it back ?
I can request an exp-run whilst being 'current responsible' (assignee)
Having said that, if you want to create a patch and take it for an exp-run, by all means :)
Also note, it's still within the Ports Framework component, and the change technically doesn't require portmgr approval. But certainly an exp-run is warranted for this kind of change
(In reply to Kubilay Kocak from comment #3)
> I can request an exp-run whilst being 'current responsible' (assignee)
>
> Having said that, if you want to create a patch and take it for an exp-run,
> by all means :)
When you want an exp-run, you assign the pr to portmgr, it'll get back to you when the exp-run is done.
OK, portmgr will handle this one.
Making the default 3.5 will break many things because of limitations in Poudriere and/or ports. Currently, Poudriere cannot calculate dependencies of dependencies correctly for Python. Because of the isolation that Poudriere enforces, it can build dependencies for the *default* version of Python rather than what is needed to satisfy the dependency. Samba and Salt are good examples - go try to build packages for them using Poudriere with 3.x set as the default Python.
IIRC, Baptiste is trying to solve issues like this with subpackages, where a port can then depend on a specific subpackage which is built with specific options rather than a port, which can have any arbitrary options set.
@Andrew, is this a change (better/worse/same) in behaviour from 3.4 being the current 3.x default?
(In reply to Kubilay Kocak from comment #8)
It's the same. A port wants the py27-foo package because it needs 2.7, but the py34-foo package was built instead because 3.4 was the default and foo supports both 2.x and 3.x. You'd just get py35-foo instead.
So that would leave us in the net same position, except with 3.5 as the default version (which is the upstream recommendation: use the latest point release of a major version branch).
Any poudriere/pkg/framework issues need to be resolved independently (im with you, this would be really nice) and does not block this issue .
Take for exp-run.
Some ports are likely not ready because of the PYO removal (PEP 0488)
-
- lines 113-115 of Mk/bsd.kde4.mk
- x11/kdelibs4/files/patch-cmake_modules_PythonMacros.cmake
- accessibility/accerciser/pkg-plist
- accessibility/orca/pkg-plist
- accessibility/py3-atspi/pkg-plist
- audio/gnome-music/pkg-plist
- audio/rhythmbox/pkg-plist
- deskutils/alacarte/pkg-plist (this one installs versioned files in an unversioned lib/python directory)
- devel/gitg/pkg-plist
- devel/py-ice/pkg-plist
- devel/py3-gobject3
- dns/bundy/pkg-plist
- editors/gedit-plugins/pkg-plist
- graphics/eog-plugins/pkg-plist
- graphics/py-opencv/pkg-plist
- math/rpcalc/pkg-plist
- math/convertall/pkg-plist
- multimedia/py3-gstreamer1/pkg-plist
- sysutils/dvdvideo/pkg-plist
- sysutils/backupchecker/pkg-plist
- x11/xcb-proto/pkg-plist
I tried to run a few tests but the version of pytest in the tree doesn't work with python 3.5
Exp-run results:
4 new failures, but it's only the tip of the iceberg, see comment #11
+ {"origin"=>"audio/gnome-music", "pkgname"=>"gnome-music-3.16.2", "phase"=>"package", "errortype"=>"???"}
+ {"origin"=>"graphics/py3-cairo", "pkgname"=>"py35-cairo-1.10.0_3", "phase"=>"configure", "errortype"=>"configure_error"}
+ {"origin"=>"sysutils/backupchecker", "pkgname"=>"backupchecker-1.7", "phase"=>"package", "errortype"=>"???"}
+ {"origin"=>"sysutils/dvdvideo", "pkgname"=>"dvdvideo-20130117_2", "phase"=>"package", "errortype"=>"???"}
23 new ports skipped due to those 4 failures
Failure logs:
For the py3-cairo failure, waflib/Build.py part of fixes it, but I couldn't run the regression tests (pytest in the tree has run time failures with python 3.5)
(In reply to Antoine Brodin from comment #11)
- deskutils/alacarte/pkg-plist (this one installs versioned files in an unversioned lib/python directory)
alacarte is broken anyway. I got this why running it:
[rm@smsh-zfs ~]> alacarte
Traceback (most recent call last):
File "/usr/local/bin/alacarte", line 21, in <module>
from Alacarte.MainWindow import main
ImportError: No module named 'Alacarte'
I have a fix to make it build with python3 and to install it into correct directory layout, but it still fails to run:
[rm@smsh-zfs ~]> alacarte
/usr/local/lib/python3.5/site-packages/Alacarte/MainWindow.py:43: Warning: invalid (NULL) pointer instance
self.tree.add_from_file(os.path.join(config.pkgdatadir, 'alacarte.ui'))
/usr/local/lib/python3.5/site-packages/Alacarte/MainWindow.py:43: Warning: g_signal_connect_object: assertion 'G_TYPE_CHECK_INSTANCE (instance)' failed
self.tree.add_from_file(os.path.join(config.pkgdatadir, 'alacarte.ui'))
/usr/local/lib/python3.5/site-packages/Alacarte/MainWindow.py:43: Warning: g_object_ref: assertion 'G_IS_OBJECT (object)' failed
self.tree.add_from_file(os.path.join(config.pkgdatadir, 'alacarte.ui'))
Segmentation fault (core dumped)
So I believe you may just mark it uncoditionally broken and exclude from exp-run.
Here is standalone chunk. Just run this in python3.5 interpreter:
>>> import gi
>>> gi.require_version('Gtk', '3.0')
>>> from gi.repository import Gtk
>>>
>>> tree = Gtk.Builder()
>>> tree.add_from_file('/usr/local/share/alacarte/alacarte.ui')
__main__:1: Warning: invalid (NULL) pointer instance
__main__:1: Warning: g_signal_connect_object: assertion 'G_TYPE_CHECK_INSTANCE (instance)' failed
__main__:1: Warning: g_object_ref: assertion 'G_IS_OBJECT (object)' failed
Segmentation fault (core dumped)
A commit references this bug:
Author: rm
Date: Sun Mar 6 22:09:24 UTC 2016
New revision: 410491
URL:
Log:
multimedia/py3-gstreamer1: fix packaging with python 3.5
PR: 204519
With hat: gnome
Changes:
head/multimedia/py3-gstreamer1/Makefile
head/multimedia/py3-gstreamer1/pkg-plist
A commit references this bug:
Author: rm
Date: Sun Mar 6 22:12:29 UTC 2016
New revision: 410493
URL:
Log:
audio/gnome-music: fix packaging with python 3.5
PR: 204519
With hat: gnome
Changes:
head/audio/gnome-music/Makefile
head/audio/gnome-music/pkg-plist
I just noticed that Python 3.5.1 was released on 2015-12-07, which fixed a number of issues: <>
(In reply to Gerard Seibert from comment #17)
Version 3.5.1 already in ports tree since 20 Dec 2015
Antoine, would you please restart the exp-run with fresh tree? There were many ports fixed so far.
Some things that probably still need fixes:
- lines 115-117 of Mk/bsd.kde4.mk
- x11/kdelibs4/files/patch-cmake_modules_PythonMacros.cmake
- accessibility/py3-speech-dispatcher
- audio/rhythmbox
- graphics/py-opencv
- math/rpcalc
- math/convertall
Also graphics/blender has USES=python:3.4 , I don't know if it can be changed to USES=python:3.4+
(In reply to Antoine Brodin from comment #21)
No, each blender release is fairly strongly tied to and only supported when built with a specific version of python, no effort is made to work with more than one python version.
There has been a new version released that isn't in ports yet, v2.77 that will use python 3.5
With only default python3 version changed there are 2 new failures:
With default python3 version changed and default python version changed there are those failures (py-opencv may have been broken before):
I can't test python kde4 ports as some dependencies fail to build with python3 (sysutils/qzeitgeist for instance)
A commit references this bug:
Author: rm
Date: Fri Sep 23 22:45:03 UTC 2016
New revision: 422698
URL:
Log:)
Changes:
head/graphics/opencv/Makefile
head/graphics/py-opencv/Makefile
head/graphics/py-opencv/pkg-plist
A commit references this bug:
Author: jbeich
Date: Sat Oct 1 15:36:15 UTC 2016
New revision: 423072
URL:
Log:)
Changes:
head/graphics/opencv/Makefile
Antoine, I reread what you said and it looks we doing something different: I mean sysutils/qzeitgeist stuff. qzeitgeist needs python for build and there is no particular python version set in Makefile, so it should build just fine with default python version (2.7).
As far I understand, you also changed "python" version in DEFAULT_VERSIONS, so your poudriere make.conf looks like that:
DEFAULT_VERSIONS=python=3.5 python3=3.5
while it should looked like that
DEFAULT_VERSIONS=python=2.7 python2=2.7 python3=3.5
because now I only interested in ports, that define python:3 or python:3.3+ in USES. I don't count that every port that have USES=python can be built with 3.5 or with 3.x ever. We now only want to change default python3 (3.4 -> 3.5) version, not the python version at all.
Would you please limit your port list for testing to only those that set:
USES=python3
USES=python3.3+
USES=python:3,build
USES=python:3,run
USES=python:3.3+,build
USES=python:3.3+,run
and let me know what's broken with 3.5 now? Thanks a lot!
I believe those 2 failures were never fixed:
Yep, and math/convertall and math/rpcalc too. kde/cmake stuff seems to be fixed, but they are out of interest at the moment. So only four ports stop the 3.4 -> 3.5 switching?
(In reply to Ruslan Makhmatkhanov from comment #29)
Probably, I will do the exp-run again when accessibility/py3-speech-dispatcher and audio/rhythmbox are fixed.
(In reply to Antoine Brodin from comment #30)
Antoine, I made the patches for them (see the "Depends on" PR's) and awaiting for maintainer approval. But maybe you can start the exp-run by applying them manually to the test tree because it may took up to 2 weeks awaiting approval? Thanks
You don't need to wait to commit them, they are fixing build-time problems when building with python 3.5, and thus, are covered by the blanket approval:
Ok, will do then. I also can't test math/convertall and math/rpcalc, because they depend upon llvm37, that's marked broken with py3.
All set
A commit references this bug:
Author: antoine
Date: Fri Oct 14 19:50:00 UTC 2016
New revision: 423986
URL:
Log:
Change the default version of python3 from 3.4 to 3.5
Thanks to Ruslan Makhmatkhanov for doing all the fixes
PR: 204519
With hat: portmgr
Changes:
head/Mk/Uses/python.mk
head/Mk/bsd.default-versions.mk
head/UPDATING | https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=204519 | CC-MAIN-2019-47 | en | refinedweb |
Type Erasure
A generic type in Java is compiled to a single class file. There aren’t separate versions of the generic type for each formal parameterized type. For example, in the following example, Gen<Integer, String> and Gen<Float, Double> aren’t separate versions of the Gen type for each formal parameterized type :
The implementation of generics utilizes type erasure. In general, here is how type. The Gen<Integer, String> and Gen<Float, Double> are same version of the Gen type for each formal parameterized type :
Of course, Gen class doesn’t exist as a separate entity. Looking at the class that now works with references of type Object, you may wonder what the advantage of being able to specify the type parameter is; after all, you can supply a reference to an object of any type for a parameter of type Object. The answer is that the type variable you supply is used by the compiler to ensure compile-time type safety. When you use an object of type Gen in your code, the compiler checks that you use it only to store objects of type Integer and String through the reference of Gen<Integer,String> and any attempt to store objects of other types as an error. When you call methods for an object of type Gen through the reference of Gen<Integer,String>, the compiler ensures that you supply references only of type Integer and String.
When you program a call to a generic method, the compiler inserts casts when the return type has been erased. For example, consider following the sequence of statements :
The return type of inst.GetT( ) is Object. The compiler automatically inserts the cast to Integer. This way to compiler ensure type safety. Following example shows how bounded type variables are erased :
Program
class Gen<T> { private T tary[]; Gen(T tar[]) { tary = tar; } void setSpecificElement(int p,T t) { tary[p]=t; } T getSpecificElement(int p) { return tary[p]; } } public class Javaapp { public static void main(String[] args) { Gen<Integer> g1 = new Gen<Integer>(new Integer[5]); g1.setSpecificElement(0,100); g1.setSpecificElement(1,200); g1.setSpecificElement(2,300); Integer i1 = g1.getSpecificElement(1); System.out.println(g1.getSpecificElement(2)); } } | https://hajsoftutorial.com/java-type-erasure/ | CC-MAIN-2019-47 | en | refinedweb |
Closed Bug 938827 Opened 6 years ago Closed 6 years ago
Remove reflection from Fennec
Native Actions/Driver
Categories
(Firefox for Android :: Testing, defect)
Tracking
()
Firefox 28
People
(Reporter: mcomella, Assigned: mcomella)
References
Details
Attachments
(11 files, 12 obsolete files)
While I have not throughly checked how possible it is, we should try to remove the reflection code from FennecNativeActions/Driver. Note that this is more likely as bug 916507 lands some changes that allow us to import org.mozilla.gecko classes directly.
Component: General → Testing
Assignee: nobody → michael.l.comella
If you feel ckitching or rnewman would be a better reviewer since they're (probably) more familiar with the @RobocopTarget stuff, feel free to pass it off to them. :P
Attachment #8343345 - Flags: review?(nalexander)
Realized I should not have removed RobocopAPI.registerEventListener just yet.
Attachment #8343347 - Attachment is obsolete: true
Comment on attachment 8343345 [details] [diff] [review] Part 1: Get LayerView in getSurfaceView. Saving Nick's sanity.
Attachment #8343345 - Flags: review?(nalexander) → review?(rnewman)
Comment on attachment 8343351 [details] [diff] [review] Part 3: Call registerEventListener directly. v2 (In reply to Richard Newman [:rnewman] from comment #7) > Saving Nick's sanity. <3
Attachment #8343351 - Flags: review?(rnewman)
Forgot to compile.
Attachment #8343386 - Flags: review?(rnewman)
Attachment #8343384 - Attachment is obsolete: true
Comment on attachment 8343345 [details] [diff] [review] Part 1: Get LayerView in getSurfaceView. Review of attachment 8343345 [details] [diff] [review]: ----------------------------------------------------------------- ::: build/mobile/robocop/FennecNativeDriver.java @@ +234,5 @@ > return 0.0f; > } > > + private LayerView getSurfaceView() { > + return mSolo.getView(LayerView.class, 0); Deliberate that you no longer log on failure?
Attachment #8343345 - Flags: review?(rnewman) → review+
Comment on attachment 8343359 [details] [diff] [review] Part 5: Remove querySql reflection. Review of attachment 8343359 [details] [diff] [review]: ----------------------------------------------------------------- ::: build/mobile/robocop/FennecNativeActions.java @@ +496,5 @@ > mSolo.drag(startingX, endingX, startingY, endingY, 10); > } > > + public Cursor querySql(final String dbPath, final String sql) { > + GeckoLoader.loadSQLiteLibs(mGeckoApp, mGeckoApp.getApplication().getPackageResourcePath()); Just call this once in the constructor (right after mGeckoApp is assigned)? Seems pointless to be hitting the synchronized block in GeckoLoader every time. Also, while you're here, s/mGeckoApp/mActivity?
Attachment #8343359 - Flags: review?(rnewman) → review+
Comment on attachment 8343386 [details] [diff] [review] Part 7: Remove preferences event reflection. v2 Review of attachment 8343386 [details] [diff] [review]: ----------------------------------------------------------------- ::: mobile/android/base/GeckoEvent.java @@ +708,1 @@ > public static GeckoEvent createPreferencesObserveEvent(int requestId, String[] prefNames) { We have too many of these. :/
Attachment #8343386 - Flags: review?(rnewman) → review+
I set up GeckoEventExpecter for re-use because this approach was cleaner than recreating the old behavior to disable reuse (though it might be safer to disallow it so future updates don't get it wrong - let me know what you think). Additionally, I took some liberties in the listener created in expectGeckoEvent to not have hashCode return 314 and each method to print a statement because it seems hashCode() is unused and I don't think we care which methods are called on listener. I also rearranged some imports.
Simplified the GeckoEventExpecter class by moving the listener construction/registry into the class constructor (with inspiration from part 10).
Attachment #8343458 - Attachment is obsolete: true
Rebase.
Comment on attachment 8343478 [details] [diff] [review] Part 9: Remove unregisterEventListener reflection. Move r+.
Attachment #8343478 - Flags: review+
Last major chunk sans any review comment patches. I store the GeckoLayerClient for unregistering the DrawListener which is not faithful to the original implementation, but I feel it is more correct. Like part 8, I took liberties with how each of the methods of the DrawListener are handled because I assume we don't need that unexpected functionality.
Review comments (call loadSQLiteLibs once & s/mGeckoApp/mActivity).
Status: NEW → ASSIGNED
Rebase.
Attachment #8343484 - Flags: review?(rnewman)
Rebase.
Rebase.
Attachment #8343487 - Flags: review?(rnewman)
Attachment #8343481 - Attachment is obsolete: true
Comment on attachment 8343485 [details] [diff] [review] Part 9: Remove unregisterEventListener reflection. Move r+'s.
Attachment #8343485 - Flags: review+
(In reply to Richard Newman [:rnewman] from comment #13) > Deliberate that you no longer log on failure? Nope! ^_^
Attachment #8343489 - Flags: review?(rnewman)
Comment on attachment 8343477 [details] [diff] [review] Part 8: Remove registerEventListener reflection. v2 Review of attachment 8343477 [details] [diff] [review]: ----------------------------------------------------------------- ::: build/mobile/robocop/FennecNativeActions.java @@ +78,2 @@ > > + private boolean mIsRegistered; This seems like something that should be volatile or an AtomicBoolean, unless you're sure that blocking and unregistering only ever happen on the same thread. @@ +80,3 @@ > > + private final String mGeckoEvent; > + private GeckoEventListener mListener; final. @@ +98,5 @@ > + @Override > + public void handleMessage(final String event, final JSONObject message) { > + FennecNativeDriver.log(FennecNativeDriver.LogLevel.DEBUG, > + "handleMessage called for: " + event + "; expecting: " + mGeckoEvent); > + mAsserter.is(event, mGeckoEvent, "Given message occured for registered event"); occurred. @@ +212,2 @@ > synchronized (this) { > mEventEverReceived = true; This is only ever assigned here, and read in eventReceived. Just make it volatile. @@ +221,1 @@ > FennecNativeDriver.log(LogLevel.ERROR, e); One line: .log(LogLevel.ERROR, "..." + message.toString(), e);
Attachment #8343477 - Attachment is obsolete: false
Comment on attachment 8343487 [details] [diff] [review] Part 10: Remove remaining reflection from FennecNativeActions. Review of attachment 8343487 [details] [diff] [review]: ----------------------------------------------------------------- ::: build/mobile/robocop/FennecNativeActions.java @@ +31,5 @@ > import com.jayway.android.robotium.solo.Solo; > > import static org.mozilla.gecko.FennecNativeDriver.LogLevel; > > public class FennecNativeActions implements Actions { I don't know if you've noticed, but FennecNativeActions has basically become RobocopAPI :P
Attachment #8343487 - Flags: review?(rnewman) → review+
Comment on attachment 8343489 [details] [diff] [review] Part 11: Log error if LayerView is null. Review of attachment 8343489 [details] [diff] [review]: ----------------------------------------------------------------- ::: build/mobile/robocop/FennecNativeDriver.java @@ +179,5 @@ > + > + if (layerView == null) { > + log(LogLevel.WARN, "getSurfaceView could not find LayerView"); > + for (final View v : mSolo.getViews()) { > + log(LogLevel.WARN, v.toString()); log(LogLevel.WARN, " View: " + v);
Attachment #8343489 - Flags: review?(rnewman) → review+
Review comments.
Rebase.
Rebase.
Review comments.
Comment on attachment 8343900 [details] [diff] [review] Part 11: Log error if LayerView is null. Move r+'s.
Attachment #8343900 - Flags: review+
Status: ASSIGNED → RESOLVED
Closed: 6 years ago
Resolution: --- → FIXED
Target Milestone: --- → Firefox 28 | https://bugzilla.mozilla.org/show_bug.cgi?id=938827 | CC-MAIN-2019-47 | en | refinedweb |
November 2013
Volume 28 Number 11
ASP.NET - Single-Page Applications: Build Modern, Responsive Web Apps with ASP.NET
By Mike Wasson. For the traditional ASP.NET developer, it can be difficult to make the leap. Luckily, there are many open source JavaScript frameworks that make it easier to create SPAs.
In this article, I’ll walk through creating a simple SPA app. Along the way, I’ll introduce some fundamental concepts for building SPAs, including the Model-View-Controller (MVC) and Model-View-ViewModel (MVVM) patterns, data binding and routing.
About the Sample App
The sample app I created is a simple movie database, shown in Figure 1. The far-left column of the page displays a list of genres. Clicking on a genre brings up a list of movies within that genre. Clicking the Edit button next to an entry lets you change that entry. After making edits, you can click Save to submit the update to the server, or Cancel to revert the changes.
Figure 1 The Single-Page Application Movie Database App
I created two different versions of the app, one using the Knockout.js library and the other using the Ember.js library. These two libraries have different approaches, so it’s instructive to compare them. In both cases, the client app was fewer than 150 lines of JavaScript. On the server side, I used ASP.NET Web API to serve JSON to the client. You can find source code for both versions of the app at github.com/MikeWasson/MoviesSPA.
(Note: I created the app using the release candidate [RC] version of Visual Studio 2013. Some things might change for the released to manufacturing [RTM] version, but they shouldn’t affect the code.)
Background
In a traditional Web app, every time the app calls the server, the server renders a new HTML page. This triggers a page refresh in the browser. If you’ve ever written a Web Forms application or PHP application, this page lifecycle should look familiar.
In an SPA, after the first page loads, all interaction with the server happens through AJAX calls. These AJAX calls return data—not markup—usually in JSON format. The app uses the JSON data to update the page dynamically, without reloading the page. Figure 2 illustrates the difference between the two approaches.
Figure 2 The Traditional Page Lifecycle vs. the SPA Lifecycle
One benefit of SPAs is obvious: Applications are more fluid and responsive, without the jarring effect of reloading and re-rendering the page. Another benefit might be less obvious and it concerns how you architect a Web app. Sending the app data as JSON creates a separation between the presentation (HTML markup) and application logic (AJAX requests plus JSON responses).
This separation makes it easier to design and evolve each layer. In a well-architected SPA, you can change the HTML markup without touching the code that implements the application logic (at least, that’s the ideal). You’ll see this in action when I discuss data binding later.
In a pure SPA, all UI interaction occurs on the client side, through JavaScript and CSS. After the initial page load, the server acts purely as a service layer. The client just needs to know what HTTP requests to send. It doesn’t care how the server implements things on the back end.
With this architecture, the client and the service are independent. You could replace the entire back end that runs the service, and as long as you don’t change the API, you won’t break the client. The reverse is also true—you can replace the entire client app without changing the service layer. For example, you might write a native mobile client that consumes the service.
Creating the Visual Studio Project
Visual Studio 2013 has a single ASP.NET Web Application project type. The project wizard lets you select the ASP.NET components to include in your project. I started with the Empty template and then added ASP.NET Web API to the project by checking Web API under “Add folders and core references for:” as shown in Figure 3.
Figure 3 Creating a New ASP.NET Project in Visual Studio 2013
The new project has all the libraries needed for Web API, plus some Web API configuration code. I didn’t take any dependency on Web Forms or ASP.NET MVC.
Notice in Figure 3 that Visual Studio 2013 includes a Single Page Application template. This template installs a skeleton SPA built on Knockout.js. It supports log in using a membership database or external authentication provider. I didn’t use the template in my app because I wanted to show a simpler example starting from scratch. The SPA template is a great resource, though, especially if you want to add authentication to your app.
Creating the Service Layer
I used ASP.NET Web API to create a simple REST API for the app. I won’t go into detail about Web API here—you can read more at asp.net/web-api.
First, I created a Movie class that represents a movie. This class does two things:
- Tells Entity Framework (EF) how to create the database tables to store the movie data.
- Tells Web API how to format the JSON payload.
You don’t have to use the same model for both. For example, you might want your database schema to look different from your JSON payloads. For this app, I kept things simple:
namespace MoviesSPA.Models { public class Movie { public int ID { get; set; } public string Title { get; set; } public int Year { get; set; } public string Genre { get; set; } public string Rating { get; set; } } }
Next, I used Visual Studio scaffolding to create a Web API controller that uses EF as the data layer. To use the scaffolding, right-click the Controllers folder in Solution Explorer and select Add | New Scaffolded Item. In the Add Scaffold wizard, select “Web API 2 Controller with actions, using Entity Framework,” as shown in Figure 4.
Figure 4 Adding a Web API Controller
Figure 5 shows the Add Controller wizard. I named the controller MoviesController. The name matters, because the URIs for the REST API are based on the controller name. I also checked “Use async controller actions” to take advantage of the new async feature in EF 6. I selected the Movie class for the model and selected “New data context” to create a new EF data context.
Figure 5 The Add Controller Wizard
The wizard adds two files:
- MoviesController.cs defines the Web API controller that implements the REST API for the app.
- MovieSPAContext.cs is basically EF glue that provides methods to query the underlying database.
Figure 6 shows the default REST API the scaffolding creates.
Figure 6 The Default REST API Created by the Web API Scaffolding
Values in curly brackets are placeholders. For example, to get a movie with ID equal to 5, the URI is /api/movies/5.
I extended this API by adding a method that finds all the movies in a specified genre:
public class MoviesController : ApiController { public IQueryable<Movie> GetMoviesByGenre(string genre) { return db.Movies.Where(m => m.Genre.Equals(genre, StringComparison.OrdinalIgnoreCase)); } // Other code not shown
The client puts the genre in the query string of the URI. For example, to get all movies in the Drama genre, the client sends a GET request to /api/movies?genre=drama. Web API automatically binds the query parameter to the genre parameter in the GetMoviesByGenre method.
Creating the Web Client
So far, I’ve just created a REST API. If you send a GET request to /api/movies?genre=drama, the raw HTTP response looks like this:
HTTP/1.1 200 OK Cache-Control: no-cache Pragma: no-cache Content-Type: application/json; charset=utf-8 Date: Tue, 10 Sep 2013 15:20:59 GMT Content-Length: 240 [{"ID":5,"Title":"Forgotten Doors","Year":2009,"Genre":"Drama","Rating":"R"}, {"ID":6,"Title":"Blue Moon June","Year":1998,"Genre":"Drama","Rating":"PG-13"},{"ID":7,"Title":"The Edge of the Sun","Year":1977,"Genre":"Drama","Rating":"PG-13"}]
Now I need to write a client app that does something meaningful with this. The basic workflow is:
- UI triggers an AJAX request
- Update the HTML to display the response payload
- Handle AJAX errors
You could code all of this by hand. For example, here’s some jQuery code that creates a list of movie titles:
$.getJSON(url) .done(function (data) { // On success, "data" contains a list of movies var ul = $("<ul></ul>") $.each(data, function (key, item) { // Add a list item $('<li>', { text: item.Title }).appendTo(ul); }); $('#movies').html(ul); });
This code has some problems. It mixes application logic with presentation logic, and it’s tightly bound to your HTML. Also, it’s tedious to write. Instead of focusing on your app, you spend your time writing event handlers and code to manipulate the DOM.
The solution is to build on top of a JavaScript framework. Luckily, you can choose from many open source JavaScript frameworks. Some of the more popular ones include Backbone, Angular, Ember, Knockout, Dojo and JavaScriptMVC. Most use some variation of the MVC or MVVM patterns, so it might be helpful to review those patterns.
The MVC and MVVM Patterns
The MVC pattern dates back to the 1980s and early graphical UIs. The goal of MVC is to factor the code into three separate responsibilities, shown in Figure 7. Here’s what they do:
- The model represents the domain data and business logic.
- The view displays the model.
- The controller receives user input and updates the model.
Figure 7 The MVC Pattern
A more recent variant of MVC is the MVVM pattern (see Figure 8). In MVVM:
- The model still represents the domain data.
- The view model is an abstract representation of the view.
- The view displays the view model and sends user input to the view model.
Figure 8 The MVVM Pattern
In a JavaScript MVVM framework, the view is markup and the view model is code.
MVC has many variants, and the literature on MVC is often confusing and contradictory. Perhaps that’s not surprising for a design pattern that started with Smalltalk-76 and is still being used in modern Web apps. So even though it’s good to know the theory, the main thing is to understand the particular MVC framework you’re using.
Building the Web Client with Knockout.js
For the first version of my app, I used the Knockout.js library. Knockout follows the MVVM pattern, using data binding to connect the view with the view model.
To create data bindings, you add a special data-binding attribute to the HTML elements. For example, the following markup binds the span element to a property named genre on the view model. Whenever the value of genre changes, Knockout automatically updates the HTML:
<h1><span data-</span></h1>
Bindings can also work in the other direction—for example, if the user enters text into a text box, Knockout updates the corresponding property in the view model.
The nice part is that data binding is declarative. You don’t have to wire up the view model to the HTML page elements. Just add the data-binding attribute and Knockout does the rest.
I started by creating an HTML page with the basic layout, with no data binding, as shown in Figure 9.
(Note: I used the Bootstrap library to style the app, so the real app has a lot of extra <div> elements and CSS classes to control the formatting. I left these out of the code examples for clarity.)
Figure 9 Initial HTML Layout
<!DOCTYPE html> <html> <head> <title>Movies SPA</title> </head> <body> <ul> <li><a href="#"><!-- Genre --></a></li> </ul> <table> <thead> <tr><th>Title</th><th>Year</th><th>Rating</th> </tr> </thead> <tbody> <tr> <td><!-- Title --></td> <td><!-- Year --></td> <td><!-- Rating --></td></tr> </tbody> </table> <p><!-- Error message --></p> <p>No records found.</p> </body> </html>
Creating the View Model
Observables are the core of the Knockout data-binding system. An observable is an object that stores a value and can notify subscribers when the value changes. The following code converts the JSON representation of a movie into the equivalent object with observables:
function movie(data) { var self = this; data = data || {}; // Data from model self.ID = data.ID; self.Title = ko.observable(data.Title); self.Year = ko.observable(data.Year); self.Rating = ko.observable(data.Rating); self.Genre = ko.observable(data.Genre); };
Figure 10 shows my initial implementation of the view model. This version only supports getting the list of movies. I’ll add the editing features later. The view model contains observables for the list of movies, an error string and the current genre.
Figure 10 The View Model
var ViewModel = function () { var self = this; // View model observables self.movies = ko.observableArray(); self.error = ko.observable(); self.genre = ko.observable(); // Genre the user is currently browsing // Available genres self.genres = ['Action', 'Drama', 'Fantasy', 'Horror', 'Romantic Comedy']; // Adds a JSON array of movies to the view model function addMovies(data) { var mapped = ko.utils.arrayMap(data, function (item) { return new movie(item); }); self.movies(mapped); } // Callback for error responses from the server function onError(error) { self.error('Error: ' + error.status + ' ' + error.statusText); } // Fetches a list of movies by genre and updates the view model self.getByGenre = function (genre) { self.error(''); // Clear the error self.genre(genre); app.service.byGenre(genre).then(addMovies, onError); }; // Initialize the app by getting the first genre self.getByGenre(self.genres[0]); } // Create the view model instance and pass it to Knockout ko.applyBindings(new ViewModel());
Notice that movies is an observableArray. As the name implies, an observableArray acts as an array that notifies subscribers when the array contents change.
The getByGenre function makes an AJAX request to the server for the list of movies and then populates the self.movies array with the results.
When you consume a REST API, one of the trickiest parts is handling the asynchronous nature of HTTP. The jQuery ajax function returns an object that implements the Promises API. You can use a Promise object’s then method to set a callback that’s invoked when the AJAX call completes successfully and another callback that’s invoked if the AJAX call fails:
app.service.byGenre(genre).then(addMovies, onError);
Data Bindings
Now that I have a view model, I can data bind the HTML to it. For the list of genres that appears in the left side of the screen, I used the following data bindings:
<ul data- <li><a href="#"><span data-</span></a></li> </ul>
The data-bind attribute contains one or more binding declarations, where each binding has the form “binding: expression.” In this example, the foreach binding tells Knockout to loop through the contents of the genres array in the view model. For each item in the array, Knockout creates a new <li> element. The text binding in the <span> sets the span text equal to the value of the array item, which in this case is the name of the genre.
Right now, clicking on the genre names doesn’t do anything, so I added a click binding to handle click events:
<li><a href="#" data- <span data-</span></a></li>
This binds the click event to the getByGenre function on the view model. I needed to use $parent here, because this binding occurs within the context of the foreach. By default, bindings within a foreach refer to the current item in the loop.
To display the list of movies, I added bindings to the table, as shown in Figure 11.
Figure 11 Adding Bindings to the Table to Display a List of Movies
<table data- <thead> <tr><th>Title</th><th>Year</th><th>Rating</th><th></th></tr> </thead> <tbody data- <tr> <td><span data-</span></td> <td><span data-</span></td> <td><span data-</span></td> <td><!-- Edit button will go here --></td> </tr> </tbody> </table>
In Figure 11, the foreach binding loops over an array of movie objects. Within the foreach, the text bindings refer to properties on the current object.
The visible binding on the <table> element controls whether the table is rendered. This will hide the table if the movies array is empty.
Finally, here are the bindings for the error message and the “No records found” message (notice that you can put complex expressions into a binding):
<p data-</p> <p data-No records found.</p>
Making the Records Editable
The last part of this app is giving the user the ability to edit the records in the table. This involves several bits of functionality:
- Toggling between viewing mode (plain text) and editing mode (input controls).
- Submitting updates to the server.
- Letting the user cancel an edit and revert to the original data.
To track the viewing/editing mode, I added a Boolean flag to the movie object, as an observable:
function movie(data) { // Other properties not shown self.editing = ko.observable(false); };
I wanted the table of movies to display text when the editing property is false, but switch to input controls when editing is true. To accomplish this, I used the Knockout if and ifnot bindings, as shown in Figure 12. The “<!-- ko -->” syntax lets you include if and ifnot bindings without putting them inside an HTML container element.
Figure 12 Enabling Editing of Movie Records
<tr> <!-- ko if: editing --> <td><input data-</td> <td><input type="number" class="input-small" data-</td> <td><select class="input-small" data-</select></td> <td> <button class="btn" data-Save</button> <button class="btn" data-Cancel</button> </td> <!-- /ko --> <!-- ko ifnot: editing --> <td><span data-</span></td> <td><span data-</span></td> <td><span data-</span></td> <td><button class="btn" data-Edit</button></td> <!-- /ko --> </tr>
The value binding sets the value of an input control. This is a two-way binding, so when the user types something in the text field or changes the dropdown selection, the change automatically propagates to the view model.
I bound the button click handlers to functions named save, cancel and edit on the view model.
The edit function is easy. Just set the editing flag to true:
self.edit = function (item) { item.editing(true); };
Save and cancel were a bit trickier. In order to support cancel, I needed a way to cache the original value during editing. Fortunately, Knockout makes it easy to extend the behavior of observables. The code in Figure 13 adds a store function to the observable class. Calling the store function on an observable gives the observable two new functions: revert and commit.
Figure 13 Extending ko.observable with Revert and Commit
Now I can call the store function to add this functionality to the model:
function movie(data) { // ... // New code: self.Title = ko.observable(data.Title).store(); self.Year = ko.observable(data.Year).store(); self.Rating = ko.observable(data.Rating).store(); self.Genre = ko.observable(data.Genre).store(); };
Figure 14 shows the save and cancel functions on the view model.
Figure 14 Adding Save and Cancel Functions
self.cancel = function (item) { revertChanges(item); item.editing(false); }; self.save = function (item) { app.service.update(item).then( function () { commitChanges(item); }, function (error) { onError(error); revertChanges(item); }).always(function () { item.editing(false); }); } function commitChanges(item) { for (var prop in item) { if (item.hasOwnProperty(prop) && item[prop].commit) { item[prop].commit(); } } } function revertChanges(item) { for (var prop in item) { if (item.hasOwnProperty(prop) && item[prop].revert) { item[prop].revert(); } } }
Building the Web Client with Ember
For comparison, I wrote another version of my app using the Ember.js library.
An Ember app starts with a routing table, which defines how the user will navigate through the app:
window.App = Ember.Application.create(); App.Router.map(function () { this.route('about'); this.resource('genres', function () { this.route('movies', { path: '/:genre_name' }); }); });
The first line of code creates an Ember application. The call to Router.map creates three routes. Each route corresponds to a URI or URI pattern:
/#/about /#/genres /#/genres/genre_name
For every route, you create an HTML template using the Handlebars template library.
Ember has a top-level template for the entire app. This template gets rendered for every route. Figure 15 shows the application template for my app. As you can see, the template is basically HTML, placed within a script tag with type=“text/x-handlebars.” The template contains special Handlebars markup inside double curly braces: {{ }}. This markup serves a similar purpose as the data-bind attribute in Knockout. For example, {{#linkTo}} creates a link to a route.
Figure 15 The Application-Level Handlebars Template
ko.observable.fn.store = function () { var self = this; var oldValue = self(); var observable = ko.computed({ read: function () { return self(); }, write: function (value) { oldValue = self(); self(value); } }); this.revert = function () { self(oldValue); } this.commit = function () { oldValue = self(); } return this; } <script type="text/x-handlebars" data- <div class="container"> <div class="page-header"> <h1>Movies</h1> </div> <div class="well"> <div class="navbar navbar-static-top"> <div class="navbar-inner"> <ul class="nav nav-tabs"> <li>{{#linkTo 'genres'}}Genres{{/linkTo}} </li> <li>{{#linkTo 'about'}}About{{/linkTo}} </li> </ul> </div> </div> </div> <div class="container"> <div class="row">{{outlet}}</div> </div> </div> <div class="container"><p>©2013 Mike Wasson</p></div> </script>
Now suppose the user navigates to /#/about. This invokes the “about” route. Ember first renders the top-level application template. Then it renders the about template inside the {{outlet}} of the application template. Here’s the about template:
<script type="text/x-handlebars" data- <h2>Movies App</h2> <h3>About this app...</h3> </script>
Figure 16 shows how the about template is rendered within the application template.
Figure 16 Rendering the About Template
Because each route has its own URI, the browser history is preserved. The user can navigate with the Back button. The user can also refresh the page without losing the context, or bookmark and reload the same page.
Ember Controllers and Models
In Ember, each route has a model and a controller. The model contains the domain data. The controller acts as a proxy for the model and stores any application state data for the view. (This doesn’t exactly match the classic definition of MVC. In some ways, the controller is more like a view model.)
Here’s how I defined the movie model:
App.Movie = DS.Model.extend({ Title: DS.attr(), Genre: DS.attr(), Year: DS.attr(), Rating: DS.attr(), });
The controller derives from Ember.ObjectController, as shown in Figure 17.
Figure 17 The Movie Controller Derives from Ember.ObjectController
App.MovieController = Ember.ObjectController.extend({ isEditing: false, actions: { edit: function () { this.set('isEditing', true); }, save: function () { this.content.save(); this.set('isEditing', false); }, cancel: function () { this.set('isEditing', false); this.content.rollback(); } } });
There are some interesting things going on here. First, I didn’t specify the model in the controller class. By default, the route automatically sets the model on the controller. Second, the save and cancel functions use the transaction features built into the DS.Model class. To revert edits, just call the rollback function on the model.
Ember uses a lot of naming conventions to connect different components. The genres route talks to the GenresController, which renders the genres template. In fact, Ember will automatically create a GenresController object if you don’t define one. However, you can override the defaults.
In my app, I configured the genres/movies route to use a different controller by implementing the renderTemplate hook. This way, several routes can share the same controller (see Figure 18).
Figure 18 Several Routes Can Share the Same Controller
App.GenresMoviesRoute = Ember.Route.extend({ serialize: function (model) { return { genre_name: model.get('name') }; }, renderTemplate: function () { this.render({ controller: 'movies' }); }, afterModel: function (genre) { var controller = this.controllerFor('movies'); var store = controller.store; return store.findQuery('movie', { genre: genre.get('name') }) .then(function (data) { controller.set('model', data); }); } });
One nice thing about Ember is you can do things with very little code. My sample app is about 110 lines of JavaScript. That’s shorter than the Knockout version, and I get browser history for free. On the other hand, Ember is also a highly “opinionated” framework. If you don’t write your code the “Ember way,” you’re likely to hit some roadblocks. When choosing a framework, you should consider whether the feature set and the overall design of the framework match your needs and coding style.
Learn More
In this article, I showed how JavaScript frameworks make it easier to create SPAs. Along the way, I introduced some common features of these libraries, including data binding, routing, and the MVC and MVVM patterns. You can learn more about building SPAs with ASP.NET at asp.net/single-page-application.
Mike Wasson is a programmer-writer at Microsoft. For many years he documented the Win32 multimedia APIs. He currently writes about ASP.NET, focusing on Web API. You can reach him at [email protected].
Thanks to the following technical expert for reviewing this article: Xinyang Qiu (Microsoft)
Xinyang Qiu is a senior Software Design Engineer in Test on the Microsoft ASP.NET team and an active blogger for blogs.msdn.com/b/webdev. He’s happy to answer ASP.NET questions or direct experts to answer your questions. Reach him at [email protected]. | https://docs.microsoft.com/en-us/archive/msdn-magazine/2013/november/asp-net-single-page-applications-build-modern-responsive-web-apps-with-asp-net | CC-MAIN-2019-47 | en | refinedweb |
Search the Community
Showing results for tags 'autoload'.
Found 1 result
Composer autoloading inconsistencies?
fivestringsurf posted a topic in Other LibrariesI've been using composer and like the idea of having managed libraries/dependencies in php. I'm having trouble understanding how to call libraries with autoloading. Some of the package authors give great directions and some don't. Things seem very inconsistent which is really annoying. For example I'm using this image library like this: use Intervention\Image\ImageManager; $imgMan = new ImageManager(array('driver' => 'gd')); //etc... Awesome! But I can't figure out how to do something similar with firephp and mpdf (namespacing)? I figured out that these do work: $firephp = FirePHP::getInstance(true); $mpdf = new mpdf(); But, why all the inconsistencies and different ways of doing things? I'd like to keep everything neat and namespaced all in a similar way. Can anyone offer some advice? | https://forums.phpfreaks.com/search/?tags=autoload&updated_after=any&sortby=relevancy&_nodeSelectName=forums_topic_node&_noJs=1 | CC-MAIN-2019-47 | en | refinedweb |
Search
Create
sustainability vocabulary
STUDY
Flashcards
Learn
Write
Spell
Test
PLAY
Match
Gravity
Terms in this set (94)
6 Sigma
A quality management system pioneered by Motorola and used by many manufacturing companies. Sigma refers to a standard deviation of a set of statistics. -
AccountAbility 1000S
AccountAbility is a not-for-profit certification and research organization founded in the UK in 1995. The 1000 Series is AccounAbility's guidelines for reporting on social, environmental and ethical performance. -
Agenda 21
A program run by the United Nations (UN) related to sustainable development and the planet's first summit to discuss global warming related issues. It is a comprehensive blueprint of action to be taken globally, nationally and locally by organizations of the UN, governments, and major groups in every area in which humans directly affect the environment. -
Biodiesel
A clean-burning, renewable alternative to standard diesel fuel. Biodiesel has become America's fastest growing alternative fuel (according to the Department of Energy).
Bottom of the Pyramid
A term developed by Stuart Hart and C. K. Prahalad referring to the poorest people in the world. Contrary to most expectations, because of their numbers, they still represent a huge market if affordable products and services can be offered to them. -
Brundtland Commission definition of Sustainability
Convened by the UN in 1983 to address concerns about deterioration of the environment, the Commission declared, "Sustainable development is development that meets the needs of the present without compromising the ability of future generations to meet their own needs." -
CAFE (Corporate Average Fuel Economy ) standards
The fuel standards for passenger cars and light trucks were established as part of the Energy Policy Conservation Act (EPCA) enacted in 1975. The Act was passed in response to the 1973-74 Arab oil embargo. -
CSR (Corporate Social Responsibility)
A business outlook that acknowledges responsibilities to stakeholders not traditionally accepted, including suppliers, customers, and employees as well as local and international communities in which it operates and the natural environment. -
Cap and Trade
Cap and trade is an environmental policy tool that delivers results with a mandatory cap on emissions while providing sources flexibility in how they comply. See carbon trading. -
Carbon Disclosure Project
An initiative by leading institutional investors (with assets of $10T) to research and rate global companies based on their risks due to climate change. -
Carbon Footprint
The total amount of greenhouse gases emitted directly and indirectly to support human activities, usually expressed in equivalent tons of either carbon or carbon dioxide. -
Carbon Neutral
Refers to achieving net zero carbon emissions by balancing a measured amount of carbon released with an equivalent amount sequestered or offset, or buying enough carbon credits to make up the difference. -
Carbon Offsets
A reduction in emissions of carbon or greenhouse gases made in order to compensate for or to offset an emission made elsewhere -
Carbon Sequestration
The process of removing carbon from the atmosphere and depositing it in subsurface saline aquifers, reservoirs, ocean water, aging oil fields, or other carbon sinks. -
Carbon Trading
Any trading system designed to offset carbon emissions from one activity (such as burning fossil fuels in manufacturing, driving, or flying) with another (such as installing more efficient technologies or planting carbon-reducing plants) -
Ceres Principles
A ten-point code of environmental conduct that is publicly and voluntarily endorsed by companies as an environmental mission statement or ethic. -
Climate Neutral
The process of offsetting carbon-producing activities with those that either reduce or capture carbon, thus credibly neutralizing the net amount of carbon released in the atmosphere from a particular activity -
Closed-loop Supply Chain
Ideally, a zero-waste supply chain that completely reuses, recycles, or composts all materials. However, the term can also be used to refer to corporate take-back programs, where companies that produce a good are also responsible for its disposal. -
Cradle-to-Cradle. -
Daly's Triangle
Daly reorders sustainability's 3Es-environment, equity, and economy- and uses a triangle to describe their relationship to each other. It emphasizes that the natural environment is the precondition for human life. -
Cogeneration
Cogeneration is the simultaneous production of electrical and thermal energy from the same fuel source. For example, surplus heat from an electric generating plant can be used for industrial processes, or space and water heating purposes. -
Dematerialization
Reducing the total material that goes toward providing benefits to customers. May be accomplished through greater efficiency, the use of better or more appropriate materials, or by creating a service that produces the same benefit as a product. -
Design for Environment
Design for Environment (DfE) is a process used in many industries to help organizations improve the environmental impact of their products and services throughout the development process. -
Dow Jones Sustainability Index
Created in 1999, the Dow Jones Sustainability Index is one of the first global indexes watching the financial performance leading companies with an emphasis on sustainability in economic, social, and environmental capacities. -
Downcycle
Most recycled industrial nutrients (materials) lose viability or value in the process of recycling. This "downcycling" means they can only be used in a degraded form for components other than their original use. -
Earth Charter
A UN declaration of fundamental values and principles considered useful by its supporters for building a just, sustainable, and peaceful global society in the 21st century
E-waste
Waste materials generated from using or discarding electronic devices (such as computers, televisions, and mobile phones). E-waste tends to be highly toxic.
Eco-efficiency
Coined by the World Business Council for Sustainable Development (WBCSD) in its 1992 publication "Changing Course". It is based on the concept of creating more goods and services while using fewer resources and creating less waste and pollution. -
Ecological Design
Defined by Sim Van der Ryn and Stuart Cowan as "any form of design that minimizes environmentally destructive impacts by integrating itself with living processes." The term helps connect scattered efforts in green architecture, sustainable agriculture, ecological engineering, ecological restoration and other fields. -
Ecological Economics
An interdisciplinary framework that seeks to merge the two historically separate fields of economics and ecology. It assumes that the economy is a subsystem of the earth's ecological system. -
ESG (Environment, Social, Governance)
Describes the three main areas of concern that have developed as the central factors in measuring the sustainability and ethical impact of an investment in a company or business. -. -
Environmental Management Equator Principles
Developed in 2002 by a group of banks, these guidelines are a framework for addressing environmental and social risks in project financing. The purpose of the principles is to screen projects for adverse environmental or human affects in order to safeguard communities and natural habitats. -
Fiduciary Responsibility
The moral, and sometimes legal, responsibility one party has to another in relationship to specific duties, such as those held by investment advisors or trustees. -
GHG Protocol
The most widely used international accounting tool for government and business leaders to understand, quantify, and manage greenhouse gas emissions. -
GPI (Genuine Progress Indicator)
An indicator developed to correct acknowledged deficiencies in the GDP that don't account for all costs or benefits of human activities. It is an attempt to provide a more accurate (quality of life) indicator for people than the GDP does for governments and corporations. -
GRI (Global Reporting Initiative)
An organization that has pioneered the development of the world's most widely used sustainability reporting framework, the Sustainability Reporting Guidelines, which allow companies, government agencies, and non-governmental organizations to report on the economic, environmental, and social dimensions of their activities, products and services -
Green Building
A comprehensive process of design and construction that employs techniques to minimize adverse environmental impacts and reduce the energy consumption of a building, while contributing to the health and productivity of its occupants. -
Green-collar Jobs
Jobs created by investments and sustainable practices. -
Greenwashing. -
Gross National Happiness (GNH)
A measure of the actual well-being of a country's citizens rather than consumption, accounting more fully for social, human and environmental realities. Its premise is that basic happiness can be measured since it pertains to quality of nutrition, housing, education, health care and community life. -
The Global Sullivan Principles (GSP)
A corporate code of conduct designed to increase the active participation of corporations in the advancement of human rights and social justice at the international level. -
IRR (Internal Rate of Return)
Used in capital budgeting to measure and compare the profitability of investments, IRR is also called the discounted cash flow rate of return (DCFROR) or simply the rate of return (ROR). -
ISO 14000
This series of standards represents environmental management standards, created by the International Organization for Standardization -
ISO 19011
This series represents environmental management and auditing standards, many of which supercede ISO 14000 standards. -
ISO 26000
This series of standards provides guidelines on social responsibility (SR) for private and public sector organizations. -
Industrial Ecology
A field of study and practice that focuses on how industry can be developed or restructured to reduce environmental burdens throughout the product life cycle. -
Kyoto Protocol
An agreement developed by and for industrial nations in 1997 at the United Nations Framework Convention on Climate Change (UNFCC) in Kyoto, Japan, to reduce their emissions of greenhouse gases by at least 5% below 1990 levels by 2012. -
Lean Manufacturing
A production practice that considers the expenditure of resources for any goal other than the creation of value for the end customer to be wasteful, and thus a target for elimination. It is often associated with reductions in inventory and transportation of manufacturing materials. -
LEED (Leadership in Energy and Environmental Design)® Rating
A registered system of rating existing and new buildings, interiors, and other components based on environmental effectiveness. -
LOHAS (Lifestyles Of Health And Sustainability)
A term used to describe the market and lifestyle of consumers interested in issues of health, wellness, ecology, sustainability, and the environment. -
Life Cycle Analysis/Assessment (LCA)
An examination, like an audit, of the total impact of a product or service's manufacturing, use, and disposal in terms of material and energy. -
Millennium Development Goals
A set of eight international development goals that all 192 United Nations member states and at least 23 international organizations have agreed to achieve by the year 2015. They include eradicating extreme poverty, reducing child mortality rates, fighting disease epidemics such as AIDS, and developing a global partnership for development -
NGO (Non-Governmental Organization)
A non-profit group or organization that is run neither by business or government created to realize particular social or economic pursuits. -
Natural Capitalism
Concept developed by Amory and Hunter Lovins and Paul Hawken criticizing industrial capitalism for not accounting for anything beyond money and goods. Natural Capitalism extends traditional capitalism by adding natural capital (the Earth's resources) and human capital as things that must be accounted for. -
Natural Step™
A trademarked, science-based framework to help organizations and communities understand and become more sustainable. -
Net Metering
An electricity policy for consumers who own (generally small) renewable energy facilities (such as wind, solar power or home fuel cells) allowing them to receive a credit for at least a portion of the electricity they generate. -
Organic
In regards to food (both plant and animal) and other agricultural products (such as cotton), a term describing the absence of pesticides, hormones, synthetic fertilizers and other toxic materials in cultivation. -
Payback Period
An accounting term indicating the time required to recoup an investment. -
Peak Oil
The point in time when the maximum rate of global petroleum extraction is reached, after which the rate of production enters terminal decline. -
Permaculture
A contraction of "permanent agriculture," it is an approach to developing ecological human habitats and food production systems focused not on the separate elements of climate, plants, animals, soils, and water use, but on their relationships and how they are placed in the landscape. -
Precautionary Principle
An approach to determining whether a given process or policy should be pursued or continued based on an analysis of the social, economic, or environmental risks associated with that activity. -
Product Stewardship
A concept whereby environmental protection centers around the product itself, and everyone involved in the lifespan of the product is called upon to take up responsibility to reduce its environmental impact. -
ROI (Return on Investment)
The profit or loss expected or resulting from an investment. Can also include the costs and benefits associated with human and natural capital. -
REACH
Registration, Evaluation, Authorisation and Restriction of Chemicals (REACH) is a European Union Regulation addressing the production and use of chemical substances, and their potential impacts on both human health and the environment. -
Remanufacturing
The process of cleaning and repairing used products and parts to be used again for replacements. -
Renewable Energy Credits (RECs)
Tradable, non-tangible energy commodities that represent proof that a quantity of electricity was generated from an eligible renewable energy resource. -
Renewable Portfolio Standards (RPS)
A regulation that requires the increased production of energy from renewable energy sources, generally by placing an obligation on electricity supply companies to produce a specified fraction of their electricity from renewable energy sources. -
RoHS Directive
The Restriction of Hazardous Substances directive is EU legislation that bans the sale of electrical and electronic products containing specific toxic contaminants. -
SROI (Social Return on Investment)
An attempt to monetize social value in order to help investors assess potential investments based on returns outside of traditional financial measures. -
Sarbanes-Oxley
A U. S. federal law enacted in 2002, which set new or enhanced standards for all U.S. public company boards, management and public accounting firms. -
Shareholder Activism
The process of dialogue with company executives and filing shareholder resolutions generates investor pressure on corporate executives, garners media attention, and educates the public on often-ignored social, environmental, and labor issues. -
Social Accountability 8000
A workplace standard and verification system, created by the human rights organization Social Accountability International (SAI), for assuring just and decent working conditions throughout a supply chain. -
Socially Responsible Investing (SRI)
Making investments with an eye towards social, environmental and financial returns. -
Stakeholders
Individuals or organizations with an interest in the success or failure of a project or entity. -
Sunk Costs
Used in business decision-making, costs which have already been incurred and which cannot be recovered to any significant degree and, thus, should be ignored. -
Take-back
A "producer responsibility" approach to facilitating reuse or recycling whereby consumers return used products back to the company that produced them. -
Tax-shifting
The objective behind tax shifting is to stop taxing the things we do want (like income and savings) and shift towards taxing things people collectively do not want (like waste and pollution). -
Tipping Point
As described by Malcolm Gladwell, the "tipping point" is the moment in an epidemic when a virus, idea or social movement reaches "critical mass." -
Triple Bottom Line
An addition of social and environmental values to the traditional economic measures of a corporation or organization's success. -
UN Global Compact
An initiative encouraging businesses to support ten fundamental principles in the area of human rights, labor standards, the environment and anti-corruption -
World Business Council on Sustainable Development (WBCSD)
A CEO-led, global association of some 200 international companies that provides a platform for companies to explore sustainable development, share knowledge, experiences and best practices, and to advocate business positions on these issues. -
Zero Waste
The goal of developing products and services, managing their use and deployment, and creating recycling systems and markets in order to eliminate the volume and toxicity of waste and materials and conserve and recover all resources. - - -
Balanced Scorecard
A process introduced by Robert S. Kaplan and David Norton in 1992 designed to give managers tools for measuring the performance of a business from a: • Financial perspective, • Customer perspective, • Business process perspective, and a • Learning and growth perspective
Basic Browns
A selection of consumers defined by the Roper ASW Green Gauge Report as the least interested in "green" or environmental issues.
Best Practices
A set of learned practices and procedures an organization finds successful in accomplishing its goals. Best practices are most successful when clearly described or codified, part of employee training, and shared throughout an organization. -
Bio-based Material
"Bio" is Greek for life. Bio-based material refers to a products main constituent consisting of a substance, or substances, originally derived from living organisms. These substances may be natural or synthesized organic compounds that exist in nature.
Fair Trade (Fairtrade)
A system of trade in which workers receive living wages and employment opportunities for the goods they produce. This system serves as an alternative approach to conventional international trade for producers who are typically economically disadvantaged artisans and farmers from developing countries. -
Biodiversity
The biological diversity of life on Earth. As human influence spreads, there is concern over the reduction of the total number of species and its effect on economics, medicine, and the ability of ecosystems to remain viable.
Biofuel
Biofuel is any fuel derived from an organic material that is not fossilized like coal or petroleum. Common sources of biofuel grown for the U.S and European markets are corn, soybeans, flaxseed and rapeseed.
Biomass
Organic, non-fossil material that is available on a renewable basis. Biomass includes all biological organisms, dead or alive, and their metabolic by-products that have not been transformed by geological processes into substances such as coal or petroleum. -
Biomimicry
Applying lessons learned from the study of natural methods and systems to the design of technology.
Bootstrapping
A term derived from a German legend about Baron Münchhausen who pulled himself from a swamp by his own shoelaces or bootstraps. It refers to starting a business with limited capital and growing it based primarily on internally-generated profit instead of external investment.
Eco-Labels
Any label that attempts to certify or distinguish a product or service in terms of environmental issues. The ISO 14021-14025 standards outline categories of eco-labels.
; | https://quizlet.com/6712073/sustainability-vocabulary-flash-cards/ | CC-MAIN-2019-47 | en | refinedweb |
Showcase your app to new users or explain functionality of new features.
It uses react-floater for positioning and styling.
And you can use your own components too!
View the demo here (or the codesandbox examples)
Chat about it in our Spectrum community
npm i react-joyride
import Joyride from 'react-joyride'; export class App extends React.Component { state = { steps: [ { target: '.my-first-step', content: 'This is my awesome feature!', }, { target: '.my-other-step', content: 'This another awesome feature!', }, ... ] }; render () { const { steps } = this.state; return ( <div className="app"> <Joyride steps={steps} ... /> ... </div> ); } }
If you need to support legacy browsers you need to include the scrollingelement polyfill.
Setting up a local development environment is easy!
Clone (or fork) this repo on your machine, navigate to its location in the terminal and run:
npm install npm link # link your local repo to your global packages npm run watch # build the files and watch for changes
Now clone and run:
npm install npm link react-joyride # just link your local copy into this project's node_modules npm start
Start coding! p | https://codeawesome.io/react.js/miscellaneous/react-joyride | CC-MAIN-2022-05 | en | refinedweb |
Important: Please read the Qt Code of Conduct -
Signal/Slot newbie
Hi, I just made my first application in QT (with QT5, QT Creator and QT Quick) and I've got the exe running and everything, but being a newbie and not used to neither OOP nor QML I feel a bit insecure. The program has worked as expected the last 50 times but at some point earlier on, it gave some weird unexpected results. It would feel better if I felt sure I knew what I was doing, and/or had a way of testing it in more detail. My code:
#ifndef MYFILE_
#define MYFILE_
#include <QObject>
class MyHandling : public QObject {
Q_OBJECT
public slots:
QString handleMyFile(bool Selection1, bool Selection2, QString inputFileName);
signals:
void valueChanged(void);
};
#endif
//-----------
//main.qml:
import QtQuick 2.1
import QtQuick.Controls 1.1
import QtQuick.Layouts 1.1
import QtQuick.Dialogs 1.0
Rectangle {
x: 0
width: 500
height: 370
color: "#d7dee0"
opacity: 1
Item { id: item // width: 100; height: 100 signal valueChanged() } Button { id: myButton x: 402 y: 236 width: 76 height: 57 text: qsTr("MyButton") z: 5 onClicked: { textError.text = MyHdlObject.handleMyFile(Selection1.checked, Selection2.checked, inputFileName.text, outputFileName.text) item.valueChanged() } } /* Some code */
}
//---------------
//main.cpp:
#include <QtGui/QGuiApplication>
#include "qtquick2applicationviewer.h"
#include "MyHandling.h"
#include <QFile>
#include <QQmlContext> //setContextProperty
QString MyHandling::handleMyFile(bool Selection1, bool Selection2, QString inputFileName, QString outputFileName)
{
/* Some code */
}
int main(int argc, char *argv[])
{
QGuiApplication app(argc, argv);
QObject *item; QtQuick2ApplicationViewer viewer; viewer.rootContext()->setContextProperty("MyHdlObject", new MyHandling()); viewer.setMainQmlFile(QStringLiteral("qml/MyApp/main.qml")); viewer.showExpanded(); item = (QObject *) viewer.rootObject();
//Point A
MyHandling sh1;
QObject::connect(item, SIGNAL(valueChanged()),
&sh1, SLOT(handleMyFile()));
//Point B
return app.exec();
}
@
I have one very specific question: If i delete the text between "Point A" and "Point B" it still works just as well as with it. But I thought that part was vital for the signal/slot stuff. I deleted it as a test expecting it to fail then. Or does it perhaps just work less reliably with that part deleted? The only thing that happens is that I get a warning that "item" isn't used.
Another question is: Is there a way you can recommend for testing the signal transfers between QML and C++, to make sure it works reliably? Obviously my idea to delete the whole signal/slot part expecting communication to die, is not a good test at all.
And a general question is if my communication between C++ and QML seems to be doing what it should?
I read several posts on similar subjects, especially those with example code, but for some reason none of those examples work (no matter if posted on qt-project, stackoverflow or Nokias site), I'm guessing it is due to changes in QT parts or something.
You are handling the file in QML, explicitly:
@
textError.text = MyHdlObject.handleMyFile(Selection1.checked, Selection2.checked, inputFileName.text, outputFileName.text)
@
That is why it works. It uses the object you create in your main C++ file:
@
viewer.rootContext()->setContextProperty("MyHdlObject", new MyHandling());
@
The other, created on a stack, is not used by the engine at all: you create it later and don't assign it to the root context.
Since you are a newbie, I'll also give you some advice:
@
QString handleMyFile(bool Selection1, bool Selection2, const QString &inputFileName);
signals:
void valueChanged() const;
@
Pass all Qt classes (especially containers, QString, QByteArray, etc.) as const references: this way it's faster and less memory-consuming (as Implicit Sharing kicks in).
Always define singals as const: they always are const, and it allows some further optimisations when you declare them as such.
Thanks. Regarding stack etc I understand what you are saying, I suppose, but I wouldn't know what to change exactly. Haven't come across any description of stack usage when reading about QT/QML/C++ but I'm guessing you're talking about function call parameters since these AFAIK are on the stack and signals & slots are actually functions. But specific help on what to change would be helpful.
I read various examples and tutorials etc. "This": doesn't say much about the QML syntax. "This": (which has errors if I try to build & run it) doesn't even use ::connect. It uses e g Q_INVOKABLE (which I would have expected I might have use for) which the other example doesn't. Seems to be some options here.
Thanks for the advice on speed impact. I have seen others use const for parameters before, didn't know why, I'm guessing it tells the compiler that they are pointers whose value won't change? I suppose that means I could/should add const also for the return value? I haven't seen anyone else using const for signals though.
I don't want to flood you by details. The interaction between C++, meta object system and QML is deep and complicated, especially for a newcomer. I suggest you to take it easy and try to develop some training projects step by step, to gradually get the idea about the whole system.
[quote]Regarding stack etc I understand what you are saying, I suppose, but I wouldn’t know what to change exactly[/quote]
Remove those lines (86-88) completely, you do not need them. What you do there is create a new object that is completely separate from the one you create in line 81. They don't know about each other, and neither does the QML engine. Don't focus on the "stack" word: the situation would have been exactly the same if you created it as pointer (with "new") there.
[quote]I read various examples and tutorials etc. [...] doesn’t even use ::connect[/quote]
Meta object system is really powerful, QML uses it everywhere. Here is the difference:
- when you run, in your QML/JS code, this expression: MyHdlObject.handleMyFile(...) you are actually invoking a function (handleMyFile) from object you have added as a root context property (MyHdlObject, added in line 81 of C++ code). To do that, this method has to be marked as Q_INVOKABLE or be a slot (all slots are invokable through meta object system)
- when you connect a signal to a slot (does not matter where: C++, JavaScript, QML) you do not invoke any function yourself. Meta object system will invoke the slot after your application emits the signal: and only then
[quote]I haven’t seen anyone else using const for signals though.[/quote]
I'm going through the documentation now and it seems that signals are ot being marked as const there. I believe this to be a bug. If you don't mark a signal as const, the compiler will not allow you to emit it in a const function. And in general, it is good practice to mark all functions that can be const as const: this keyword - as you correctly assume - tells the compiler "this stuff should not change the state of the current object". This way it achieves 2 goals: on one hand the compiler will throw an error if you accidentally try to change the state inside a const function, and on the other - it allows the compiler to optimize the code more aggressively (at least in theory).
Thanks for all the input. I suppose you are saying that at this stage I might as well delete the signal/slot part. Actually I don't mind doing that as long as it still works reliably..
It seems to work reliably 99 times out of 100 but sometimes strange things happen. If you say I haven't caused this myself by bad coding then I would suspect the Qt environment, since I usually run it under Qt Creator (ctrl-R) and I've seen some quirks in Qt Creator both during debugging,linking and running which usually disappears after some things like restarting, cleaning, rebuildng etc. (BTW since a week I can't open QML files graphically in Qt Creator an it's not just my project but also e g the examples so I think I'll have to reinstall it again, so it doesn't seem to be bug free).
I have two goals with this: One is to get it to work (it is not just for test, I intend to use this code for a fun shareware application), the other is to try Qt for the first time. I suppose that if I want to do more projects in Qt which use the Quick part, I should read up on the basics then.
[quote author="DavidGGG" date="1393168856". [/quote]
Both ways are valid, fully supported and "official", don't worry :) | https://forum.qt.io/topic/38066/signal-slot-newbie | CC-MAIN-2022-05 | en | refinedweb |
PROLOGThis manual page is part of the POSIX Programmer's Manual. The Linux implementation of this interface may differ (consult the corresponding Linux manual page for details of Linux behavior), or the interface may not be implemented on Linux.
NAMEwordexp.h — word-expansion types
SYNOPSIS
#include <wordexp.h>
DESCRIPTIONThe <wordexp.h> header shall define the structures and symbolic constants used by the wordexp() and wordfree() functions.
The <wordexp.h> header shall define the wordexp_t structure type, which shall include at least the following members:
size_t we_wordc Count of words matched by words. char **we_wordv Pointer to list of expanded words. size_t we_offs Slots to reserve at the beginning of we_wordv.
The <wordexp.h> header shall define the following symbolic constants for use as flags for the wordexp() function:
- <wordexp.h> header shall define the following symbolic constants.
The <wordexp.h> header shall define the size_t type as described in <stddef.h>.
The following shall be declared as functions and may also be defined as macros. Function prototypes shall be provided.
int wordexp(const char *restrict, wordexp_t *restrict, int); void wordfree(wordexp_t *);
The following sections are informative.
APPLICATION USAGENone.
RATIONALENone.
FUTURE DIRECTIONSNone.
SEE ALSO<stddef.h>
The System Interfaces volume of POSIX.1‐2008, Section 2.6, Word Expansions . | https://jlk.fjfi.cvut.cz/arch/manpages/man/wordexp.h.0p.en | CC-MAIN-2019-47 | en | refinedweb |
InControl requires a very specific set of input settings in Unity. You can generate the proper setup for through the editor menu:
InControl > Setup Input Manager
This will regenerate the
ProjectSettings/InputManager.asset file. If you require some settings of your own, you can add them to the end of the newly generated list and InControl will do its best to preserve them.
Note: InControl contains an editor script that will automatically check this asset. A warning will appear in the console letting you know when it needs to be regenerated.
Next, you'll need a script attached to a GameObject to initialize and update InControl. For convenience, there is a manager component included. You can add it to the hierarchy through the editor menu:
GameObject > InControl > Manager
You need not adjust any of its settings for now.
The project is isolated under the C# namespace
InControl. The primary API entry point is the
InputManager class.
Note: It is a good idea to alter the execution order of the
InControlManager component so that every other object which queries the input state gets a consistent value for the duration of the frame, otherwise the update may be called mid-frame and some objects will get the input state from the previous frame while others get the state for the current frame.
By default, InControl reports the Y-axis as positive pointing up to match Unity. You can invert this behavior by setting the
Invert Y Axis option in the
InControlManager component.
Now that you have everything set up, you can query for devices and controls. The active device is the device that last received input.
InputDevice device = InputManager.ActiveDevice; InputControl control = device.GetControl( InputControlType.Action1 )
Query an indexed device when multiple devices are present like so:
var player1 = InputManager.Devices[0];
Note: This is not a good way to assign player order, though. Please read the section on Assigning Devices To Players under “Limitations & Best Practices” for more information.
Given a control, there are several properties to query:
control.IsPressed; // bool, is currently pressed control.WasPressed; // bool, pressed since previous tick control.WasReleased; // bool, released since previous tick control.HasChanged; // bool, has changed since previous tick control.State; // bool, is currently pressed (same as IsPressed) control.Value; // float, in range -1..1 for axes, 0..1 for buttons / triggers control.LastState; // bool, previous tick state control.LastValue; // float, previous tick value
Controls also implement implicit conversion operators for
bool and
float which allows for slightly simpler syntax:
if (InputManager.ActiveDevice.GetControl( InputControlType.Action3 )) { player.Boost(); }
The
InputDevice class provides several shortcut properties to the standardized controls which can make for more pleasantly readable code:
if (InputManager.ActiveDevice.Action1.WasPressed) { player.Jump(); }
It also provides a few properties that each return special directional controls aggregated from individual controls for ease of use:
OneAxisInputControl LeftStickX; OneAxisInputControl LeftStickY; OneAxisInputControl RightStickX; OneAxisInputControl RightStickY; OneAxisInputControl DPadX; OneAxisInputControl DPadY; TwoAxisInputControl RightStick; TwoAxisInputControl LeftStick; TwoAxisInputControl DPad; TwoAxisInputControl Direction;
OneAxisInputControl has identical behavior to other controls, but its value is a combination of two directions (left and right or up and down).
TwoAxisInputControl behaves similar to other controls, but provides a
Vector2 value, which a combination of the four directions it is made up of. It can also implicitly be cast to
Vector2 and
Vector3 for convenience.
The
Direction property is a combination of the D-Pad and Left Stick. This is a often a useful simplification since not all controllers have both.
Finally, you can subscribe to events to be notified when the active device changes, or devices are attached/detached:
InputManager.OnDeviceAttached += inputDevice => Debug.Log( "Attached: " + inputDevice.Name ); InputManager.OnDeviceDetached += inputDevice => Debug.Log( "Detached: " + inputDevice.Name ); InputManager.OnActiveDeviceChanged += inputDevice => Debug.Log( "Switched: " + inputDevice.Name ); | http://www.gallantgames.com/pages/incontrol-getting-started | CC-MAIN-2019-47 | en | refinedweb |
How do I increase the cell width of the Jupyter/ipython notebook in my browser?
I would like to increase the width of the ipython notebook in my browser. I have a high-resolution screen, and I would like to expand the cell width/size to make use of this extra space.
Thanks!
edit: 5/2017
I now use jupyterthemes:
and this command:
jt -t oceans16 -f roboto -fs 12 -cellw 100%
which sets the width to 100% with a nice theme.
If you don't want to change your default settings, and you only want to change the width of the current notebook you're working on, you can enter the following into a cell:
from IPython.core.display import display, HTML display(HTML("<style>.container { width:100% !important; }</style>"))
From: stackoverflow.com/q/21971449 | https://python-decompiler.com/article/2014-02/how-do-i-increase-the-cell-width-of-the-jupyter-ipython-notebook-in-my-browser | CC-MAIN-2019-47 | en | refinedweb |
A PDF document can contain a collection of fields for gathering information from the user. This project allows you to extract the data stored in these fields. This project is dependent on the PDF File Analyzer With C# Parsing Classes (Version 2.1). The software implements Section 8.6 Interactive Forms of “PDF Reference, Sixth Edition, Adobe Portable Document Format Version 1.7 November 2006”.
To extract the data fields, you supply a PDF file name. If the file is encrypted, you need to supply the password. The library will open the file and read its main structure. Next, it will read the interactive data fields. The result is an array of fields containing the field names and user entered data. You can serialize this array to an XML file.
Start the program. Press Open PDF File button. Use the Open file dialog to open a PDF file containing interactive data fields. The demo program will display the number of pages in your document. The number of indirect objects. The number of interactive fields of data in your document. And the number of digital signatures. Press Save Form Data and the program will save it to an XML file with the same name as your PDF. The XML file will be displayed by Notepad.
Save the PdfFileAnalyzer.dll library within your development area. Add the three source files included in the distribution PdfGetFormData.cs, PdfFieldData.cs and PdfFormData.cs to your project. Add the namespace PdfExtractFormData to your using list. Add reference to the PdfFileAnalyzer.dll. Add using PdfFileAnalyzer to your source.
PdfExtractFormData
using
PdfFileAnalyzer
Create a PDF form data reader. This is a derived class of PdfReader from the PdfFileAnalyzer.
PdfReader
PdfGetFormData GetFormData = new PdfGetFormData();
Open the PDF file.
// open without a password
bool result = GetFormData.OpenPdfFile(PdfFileName);
// or, open with a password
bool result = GetFormData.OpenPdfFile(PdfFileName, Password);
All errors, except encryption errors, will throw an exception. The returned result is true if the file was opened successfully. If the file is password protected, and password was not given or was wrong, the result is false. Examine the property DecryptionStatus. If it is InvalidPassword and if you know the password, you can provide it with TestPassword method. Please review the PdfExtractFormData.cs for full example.
true
false
DecryptionStatus
InvalidPassword
TestPassword
// set the password
bool Result = GetFormData.TestPassword(Password);
After the file is successfully open, get the interactive data fields.
// get form data
PdfFieldData[] FieldDataArray = GetFormData.GetFields();
If FieldDataArray is null, the PDF file does not have interactive data fields.
FieldDataArray
null
The PDF document form data is stored in an array of PdfFieldData elements. Within the PDF documents, these fields are organized in hierarchical structure. The index field (zero based) is an index into the PdfFieldData array. The Parent field is the index of the parent of the current field. Parent field of -1 indicates a root field. You can navigate from any field back to the root.
PdfFieldData
Parent
-1
The next 4 fields are defined in the PDF specification manual page 675 table 8.69. If the field Type (Key=FT) is blank, it is not a data field. It is part of the tree hierarchy. There are 4 types of data fields: Button (Btn), Text (Tx), Choice (Ch) and Signature (Sig). Each field has a name (Key=T) and an alternate- name (Key=TU) and a value (Key=V). The name and the alternate name are assigned by the PDF document creator. The value is entered by the user of the document. If the value is an empty string, the user did not enter a value. The values for buttons and choices are taken from a built-in list assigned by the document creator. The user selects the value from the list. If a choice field has multi-choice capability, the selected choices will be separated by end of line. Signature fields are handled differently than the other types of fields. Signature case is described below:
Key=FT
Btn
Tx
Ch
Sig
Key=T
Key=TU
Key=V
string
public class PdfFieldData
{
public int Index; // field index into the form array
public int Parent; // parent data field
public string Type; // Btn, Tx, Ch, Sig or empty
public string Name; // field name
public string AltName; // field alternate name
public string Value; // field value or empty
}
If the field Type is signature, the value field is “Signature n”. Where n is the index number of the signature into a result array. If there is one signature, the value will be Signature 0. And the array has one element. The data associated with all the signature fields is stored in an array of PDF dictionaries.
Type
Signature n
n
Signature 0
// get signature array
PdfDictionary[] Signatures = GetFormData.SignatureArray;
If(Signatures == null) {// there are no signatures}
// get the first signature information
PdfDictionary Signature = Signatures[0];
Digital signatures are described in the PDF specification document in Section 8.7 page 725. The signature dictionary is detailed in Table 8.102 on page 727. The PdfFileAnalyzer library allows you to extract any entry in this dictionary.
The button “Save First Signature” allows you to save a signature dictionary in a text format. It will be saved to a file name as the PDF file but with extension “.sig”. The conversion of signature dictionary to text is done by:
string Text = GetFormData.SigDictionary(index);
The PdfGetFormData is providing one method as an example how to extract data from the signature dictionary. The example shows how to extract the encrypted byte array of the signature.
PdfGetFormData
byte[] Contents = GetFormData.SigContents. | https://www.codeproject.com/Articles/5140785/Extract-User-Data-Fields-From-Fillable-PDF-Documen | CC-MAIN-2019-47 | en | refinedweb |
30 Docker Interview Questions to Ace DevOps Interview
Alex 👨🏼💻FullStack.Cafe
Updated on
・14 min read
With substantial growth forecasted for the application container market (from $762 million in 2016 to $2.7 billion by 2020, according to 451 Research), demand for container skills is at a high. Software engineers, Information Architects and DevOps engineers with Docker are in seriously high demand.
Originally published on FullStack.Cafe - Never Fail Your Tech Interview Again
Q1: What is the need for DevOps?
Topic: DevOps
Difficulty: ⭐
Nowadays.
🔗 Source: edureka.co
Q2: What is Docker?
Topic: Docker
Difficulty: ⭐
-.
🔗 Source: edureka.co
Q3: What are the advantages of DevOps?
Topic: DevOps
Difficulty: ⭐⭐
Technical benefits:
- Continuous software delivery
- Less complex problems to fix
- Faster resolution of problems
Business benefits:
- Faster delivery of features
- More stable operating environments
- More time available to add value (rather than fix/maintain)
🔗 Source: edureka.co
Q4: What is the function of CI (Continuous Integration) server?
Topic: DevOps
Difficulty: ⭐⭐.
🔗 Source: linoxide.com
Q5: How to build envrionment-agnostic systems with Docker?
Topic: Docker
Difficulty: ⭐⭐
There are three main features helping to achieve that:
- Volumes
- Environment variable injection
- Read-only file systems
🔗 Source: rafalgolarz.com
Q6: What is the difference between the
COPY and
ADD commands in a Dockerfile?
Topic: Docker
Difficulty: ⭐⭐ /.
🔗 Source: stackoverflow.com
Q7: What is Docker image?
Topic: Docker
Difficulty: ⭐⭐.
🔗 Source: edureka.co
Q8: What is Docker container?
Topic: Docker
Difficulty: ⭐⭐.
🔗 Source: edureka.co
Q9: What is Docker hub?
Topic: Docker
Difficulty: ⭐⭐
Docker hub is a cloud-based registry service which allows you to link to code repositories, build your images and test them, stores manually pushed images, and links to Docker cloud so you can deploy images to your hosts. It provides a centralized resource for container image discovery, distribution and change management, user and team collaboration, and workflow automation throughout the development pipeline.
🔗 Source: edureka.co
Q10: What are the various states that a Docker container can be in at any given point in time?
Topic: Docker
Difficulty: ⭐⭐
There are four states that a Docker container can be in, at any given point in time. Those states are as given as follows:
- Running
- Paused
- Restarting
- Exited
🔗 Source: mindmajix.com
Q11: Is there a way to identify the status of a Docker container?
Topic: Docker
Difficulty: ⭐⭐.
🔗 Source: mindmajix.com
Q12: What are the most common instructions in Dockerfile?
Topic: Docker
Difficulty: ⭐⭐.
🔗 Source: knowledgepowerhouse.com
Q13: What type of applications - Stateless or Stateful are more suitable for Docker Container?
Topic: Docker
Difficulty: ⭐⭐.
🔗 Source: mindmajix.com
Q14: Explain basic Docker usage workflow
Topic: Docker
Difficulty: ⭐⭐⭐
-).
+------------+ docker build +--------------+ docker run -dt +-----------+ docker exec -it +------+ | Dockerfile | --------------> | Image | ---------------> | Container | -----------------> | Bash | +------------+ +--------------+ +-----------+ +------+ ^ | docker pull | +--------------+ | Registry | +--------------+
🔗 Source: stackoverflow.com
Q15: What is the difference between Docker Image and Layer?
Topic: Docker
Difficulty: ⭐⭐⭐
- Image: A Docker image is built up from a series of read-only layers
- Layer: Each layer represents an instruction in the image’s Dockerfile.
The below Dockerfile contains four commands, each of which creates a layer.
FROM ubuntu:15.04 COPY . /app RUN make /app CMD python /app/app.py
Importantly, each layer is only a set of differences from the layer before it.
🔗 Source: stackoverflow.com
Q16: What is virtualisation?
Topic: Docker
Difficulty: ⭐⭐⭐
In its conceived form, virtualisation.
The net effect is that virtualization allows you to run two completely different OS on same hardware. Each guest OS goes through all the process of bootstrapping, loading kernel etc. You can have very tight security, for example, guest OS can't get full access to host OS or other guests and mess things up.
The virtualization method can be categorized based on how it mimics hardware to a guest operating system and emulates guest operating environment. Primarily, there are three types of virtualization:
- Emulation
- Paravirtualization
- Container-based virtualization
🔗 Source: stackoverflow.com
Q17: What is Hypervisor?
Topic: Docker
Difficulty: ⭐⭐⭐.
🔗 Source: stackoverflow.com
Q18: What is Docker Swarm?
Topic: Docker
Difficulty: ⭐⭐⭐
Docker Swarm is native clustering for Docker. It turns a pool of Docker hosts into a single, virtual Docker host. Docker Swarm serves the standard Docker API, any tool that already communicates with a Docker daemon can use Swarm to transparently scale to multiple hosts.
🔗 Source: edureka.co
Q19: How will you monitor Docker in production?
Topic: Docker
Difficulty: ⭐⭐⭐.
🔗 Source: knowledgepowerhouse.com
Q20: What is an orphant volume and how to remove it?
Topic: Docker
Difficulty: ⭐⭐⭐⭐
An orphant volume is a volume without any containers attached to it. Prior Docker v. 1.9 it was very problematic to remove it.
🔗 Source: rafalgolarz.com
Q21: What is Paravirtualization?
Topic: Docker
Difficulty: ⭐⭐⭐⭐.
🔗 Source: stackoverflow.com
Q22: How is Docker different from a virtual machine?
Topic: Docker
Difficulty: ⭐⭐⭐⭐.
🔗 Source: stackoverflow.com
Q23: Can you explain dockerfile ONBUILD instruction?
Topic: Docker
Difficulty: ⭐⭐⭐⭐
The
ONBUILD instruction adds to the image a trigger instruction to be executed at a later time, when the image is used as the base for another build. This is useful if you are building an image which will be used as a base to build other images, for example an application build environment or a daemon which may be customized with user-specific configuration.
🔗 Source: stackoverflow.com
Q24: Is it good practice to run stateful applications on Docker? What are the scenarios where Docker best fits in?
Topic: Docker
Difficulty: ⭐⭐⭐⭐
he problem with statefull docker aplications is that they by default store their state (data) in the containers filesystem. Once you update your software version or want to move to another machine its hard to retrieve the data from there.
What you need to do is bind a volume to the container and store any data in the volume.
if you run your container with:
docker run -v hostFolder:/containerfolder any changes to
/containerfolder will be persisted on the
hostfolder. Something similar can be done with a nfs drive. Then you can run you application on any host machine and the state will be saved in the nfs drive.
🔗 Source: stackoverflow.com
Q25: Can you run Docker containers natively on Windows?
Topic: Docker
Difficulty: ⭐⭐⭐⭐
With Windows Server 2016 you can run Docker containers natively on Windows, and with Windows Nano Server you’ll have a lightweight OS to run inside containers, so you can run .NET apps on their native platform.
🔗 Source: rafalgolarz.com
Q26: How does Docker run containers in non-Linux systems?
Topic: Docker
Difficulty: ⭐⭐⭐⭐⭐.
If containers are possible because of the features available in the Linux kernel, then the obvious question is that how do non-Linux systems run containers. Both Docker for Mac and Windows use Linux VMs to run the containers. Docker Toolbox used to run containers in Virtual Box VMs. But, the latest Docker uses Hyper-V in Windows and Hypervisor.framework in Mac.
🔗 Source: stackoverflow.com
Q27: How containers works at low level?
Topic: Docker
Difficulty: ⭐⭐⭐⭐⭐
Around 2006, people including some of the employees at Google implemented new Linux kernel level feature called namespaces (however the idea long before existed in FreeBSD). One function of the OS is to allow sharing of global resources like network and disk to kind of virtualization and isolation for global resources.
This is how Docker works: Each container runs in its own namespace but uses exactly the same kernel as all other containers. The isolation happens because kernel knows the namespace that was assigned to the process and during API calls it makes sure that process can only access resources in its own namespace.
🔗 Source: stackoverflow.com
Q28: Name some limitations of containers vs VM
Topic: Docker
Difficulty: ⭐⭐⭐⭐⭐
Just to name a few:
- You can't run completely different OS in containers like in VMs. However you can run different distros of Linux because they do share the same kernel. The isolation level is not as strong as in VM. In fact, there was a way for "guest" container to take over host in early implementations.
- Also you can see that when you load new container, the entire new copy of OS doesn't start like it does in VM.
- All containers share the same kernel. This is why containers are light weight.
- Also unlike VM, you don't have to pre-allocate significant chunk of memory to containers because we are not running new copy of OS. This enables to run thousands of containers on one OS while sandboxing them which might not be possible to do if we were running separate copy of OS in its own VM.
🔗 Source: stackoverflow.com
Q29: How to use Docker with multiple environments?
Topic: Docker
Difficulty: ⭐⭐⭐⭐⭐.
docker-compose -f docker-com
🔗 Source: stackoverflow.com
Q30: Why Docker compose does not wait for a container to be ready before moving on to start next service in dependency order?
Topic: Docker
Difficulty: ⭐⭐⭐⭐⭐.
🔗 Source: docs.docker.com
Thanks 🙌 for reading and good luck on your interview!
Please share this article with your fellow devs if you like it!
Check more FullStack Interview Questions & Answers on 👉
How to refill someone’s “cup?”
Sometimes we rely so much on our friends and coworkers that we often forget to ma...
Awesome post! One question though: why is everyone focusing on Docker so much when Kubernetes, which arguably most people use nowadays, uses cri-o, rkt or similar Docker replacements most of the time? Do ker Swarm is pretty much dead now. I'd argue that knowing how Helm charts and k8s YAML works is much more important than writing Dockerfiles, and CI/CD is handled by GitLab anyways, I guess ...
Mostly because Docker is focused on dev workflows, whereas K8S is focused on production workflow. IMO, dev use docker containers to build and test app, then, ops push this in production using K8S.
i literally passed by those docks this afternoon. That's New Westminster docks. | https://dev.to/fullstackcafe/30-docker-interview-questions-to-ace-devops-engineer-interview-2277 | CC-MAIN-2019-47 | en | refinedweb |
A Difference of Normals (DoN) scale filter implementation for point cloud data. More...
#include <pcl/features/don.h>
A Difference of Normals (DoN) scale filter implementation for point cloud data.
For each point in the point cloud two normals estimated with a differing search radius (sigma_s, sigma_l) are subtracted, the difference of these normals provides a scale-based feature which can be further used to filter the point cloud, somewhat like the Difference of Guassians in image processing, but instead on surfaces. Best results are had when the two search radii are related as sigma_l=10*sigma_s, the octaves between the two search radii can be though of as a filter bandwidth. For appropriate values and thresholds it can be used for surface edge extraction.
Definition at line 68 of file don.h.
Creates a new Difference of Normals filter.
Definition at line 84 of file don.h.
References pcl::Feature< PointInT, PointOutT >::feature_name_.
Computes the DoN vector for each point in the input point cloud and outputs the vector cloud to the given output.
Implements pcl::Feature< PointInT, PointOutT >.
Definition at line 85 of file don.hpp.
References pcl::PointCloud< T >::points.
Initialize for computation of features.
Reimplemented from pcl::Feature< PointInT, PointOutT >.
Definition at line 44 of file don.hpp. | http://docs.pointclouds.org/1.7.0/classpcl_1_1_difference_of_normals_estimation.html | CC-MAIN-2019-47 | en | refinedweb |
Created on 2007-02-28 12:04 by gagern, last changed 2011-07-14 12:29 by srikanths. This issue is now closed.
The body of a multipart/signed message has to remain unmodified for the signature to stay intact. Rewrapping headers of nested MIME parts breaks signatures.
So I disabled header rewrapping for multipart/signed, by adding a new handler to the email.Generator class.
There still remains an issue about leading spaces in header values breaking signatures.
The supplied patch is against the latest subversion sources, r54016.
Related issues:
Python bug #968430
Mailman bug #815297
Thanks for your patch! Could you work up some tests for this, too?
Assigning to Barry.
Looks like I missed your comments on this patch.
What kind of tests do you have in mind?
Tests demonstrating where current implementation fails and my patch will
help? Or rather tests checking that this patch won't break anything
else? The former would be easy enough, but for the latter I'm not sure
how far this would go, as people tend to make strange assumptions I
would never have thought of.
I'd like some tests demonstrating where the current implementation fails
and your patch helps, yes.
Take the attached test5.eml. Run it through the following python script:
import email
print (email.message_from_file(open("test5.eml")).as_string(False))
The result will have both instances of the X-Long-Line header rewrapped.
As the second instance is included in the digest calculation, the
signature verification will now fail.
This is a real world signature algorithm, following RFC 3156 (if I
didn't make a mistake). If you have an OpenPGP-enabled mailreader (e.g.
enigmail for Thunderbird) and have some way of injecting a mail as is
into your mail folders (e.g. a maildir-based server), then you can use
this setup to verify that the signature was correct in the first place
and is broken after parsing and reconstruction by python.
If you don't have such a setup available, and you don't believe me that
rewrapping the header breaks the signature, then I could either devise
some unrealistic but easy-to-check signing process, or could try to get
this working with an S/MIME signature using an X.509 certificate. I
would rather avoid this, though.
Let's get some traction here, please!
Attached is a test case which will demonstrate the issue. It includes the content of test5.eml as a string so that it won't require additional files. It produces both human-readable output and a suitable exit status. Turning it into a unit test should be easy as well.
It doesn't do signature verification, but uses simple string comparison instead. The rationale is that anything changing the string would break the signature as well. That should be enough for unit tests.
Please change stage to "patch review".
Martin, can you provide a true unit test? Lib\email\test\test_email.py has many examples, and something like this would fit in there.
OK, here is a patch providing both two test cases and the fix for current trunk. Will probably hack something for python 3 as well, although there the Message.as_string approach works due to the new headerlength argument defaulting to 0. So there I'd adjust the patch
I also included a second test e-mail together with two disabled test cases in order to address the whitespace issue I mentioned. Would be nice to have a fix for these as well, but I assume you don't want known to fail test cases without a fix in trunk unless it's really serious, right?
In any case, the fact that there should be at least four tests, maybe more in the future, all dealing with signature preservation, led me to have a class dedicated to them, instead of only adding methods to one of the existing classes. I hope you agree with that decision.
Here is the corresponding path for python3 (py3k branch). It's mostly the same, except for one additional test which ensures header preservation even if the maxheaderlen argument to Message.as_string is greater than 0. It's called test_long_headers_as_string_maxheaderlen.
I've committed fix and the non-disabled tests to trunk in r77517. I updated the comments to point to the relevant RFC and note that the problem is not fixed, just mitigated.
I've made a note of the additional tests in my issues list for the email package. I'm not sure we can fix the whitespace problem in the 2.x email package.
You missed a digit in the test comment:
s/See issue 96843/See issue 968430/
I actually had the wrong message number entirely. I was trying to reference this one, since it has the additional tests. Fixed in r77525.
I backported the fix to 2.6 in r77526 and r77527, forwarded ported to py3k in r77542 (with the addition of the new test), and backported to 3.1 in r77546.
I'm going to close this issue, but we aren't forgetting about the whitespace issues.
See issue 1670765 for more discussion of the whitespace issues.
Wrong issue number again, or did you deliberately try to catch me in an infinite see-also loop? ;-)
I've tried to work out what issue you meant, but failed so far.
Heh. Copy and paste error. I copied the issue number I wanted to reference, then copied the issue number I needed to open in order to paste the reference, and then promptly forgot that I had to recopy the issue number to paste it...
Anyway, the correct cross reference is to issue 968430. Thanks for keeping me accurate, again. (Hopefully I did the copy and paste right this time....:) | https://bugs.python.org/issue1670765 | CC-MAIN-2019-47 | en | refinedweb |
- Type:
New Feature
- Status: Resolved
- Priority:
Low
- Resolution: Fixed
-
- Component/s: Tool/nodetool
- Labels:None
You can find the bash-completion file at
it uses cqlsh to get keyspaces and namespaces and could use an environment variable (not implemented) to get access which cqlsh if authentification is needed. But I think that's really a good start
| https://issues.apache.org/jira/browse/CASSANDRA-6421?attachmentOrder=asc | CC-MAIN-2019-47 | en | refinedweb |
The Ultimate Guide To Building Scalable Web Scrapers With Scrapy
Web scraping is a way to grab data from websites without needing access to APIs or the website’s database. You only need access to the site’s data — as long as your browser can access the data, you will be able to scrape it.
Realistically, most of the time you could just go through a website manually and grab the data ‘by hand’ using copy and paste, but in a lot of cases that would take you many hours of manual work, which could end up costing you a lot more than the data is worth, especially if you’ve hired someone to do the task for you. Why hire someone to work at 1–2 minutes per query when you can get a program to perform a query automatically every few seconds?
For example, let’s say that you wish to compile a list of the Oscar winners for best picture, along with their director, starring actors, release date, and run time. Using Google, you can see there are several sites that will list these movies by name, and maybe some additional information, but generally you’ll have to follow through with links to capture all the information you want.
Obviously, it would be impractical and time-consuming to go through every link from 1927 through to today and manually try to find the information through each page. With web scraping, we just need to find a website with pages that have all this information, and then point our program in the right direction with the right instructions.
In this tutorial, we will use Wikipedia as our website as it contains all the information we need and then use Scrapy on Python as a tool to scrape our information.
A few caveats before we begin:
Data scraping involves increasing the server load for the site that you’re scraping, which means a higher cost for the companies hosting the site and a lower quality experience for other users of that site. The quality of the server that is running the website, the amount of data you’re trying to obtain, and the rate at which you’re sending requests to the server will moderate the effect you have on the server. Keeping this in mind, we need to make sure that we stick to a few rules.
Most sites also have a file called robots.txt in their main directory. This file sets out rules for what directories sites do not want scrapers to access. A website’s Terms & Conditions page will usually let you know what their policy on data scraping is. For example, IMDB’s conditions page has the following clause:
Robots and Screen Scraping: You may not use data mining, robots, screen scraping, or similar data gathering and extraction tools on this site, except with our express-written consent as noted below.
Before we try to obtain a website’s data we should always check out the website’s terms and
robots.txt to make sure we are obtaining legal data. When building our scrapers, we also need to make sure that we do not overwhelm a server with requests that it can’t handle.
Luckily, many websites recognize the need for users to obtain data, and they make the data available through APIs. If these are available, it’s usually a much easier experience to obtain data through the API than through scraping.
Wikipedia allows data scraping, as long as the bots aren’t going ‘way too fast’, as specified in their
robots.txt. They also provide downloadable datasets so people can process the data on their own machines. If we go too fast, the servers will automatically block our IP, so we’ll implement timers in order to keep within their rules.
Getting Started, Installing Relevant Libraries Using Pip
First of all, to start off, let’s install Scrapy.
Windows
Install the latest version of Python from
Note: Windows users will also need Microsoft Visual C++ 14.0, which you can grab from “Microsoft Visual C++ Build Tools” over here.
You’ll also want to make sure you have the latest version of pip.
In cmd.exe, type in:
python -m pip install --upgrade pip pip install pypiwin32 pip install scrapy
This will install Scrapy and all the dependencies automatically.
Linux
First you’ll want to install all the dependencies:
In Terminal, enter:
sudo apt-get install python3 python3-dev python-pip libxml2-dev libxslt1-dev zlib1g-dev libffi-dev libssl-dev
Once that’s all installed, just type in:
pip install --upgrade pip
To make sure pip is updated, and then:
pip install scrapy
And it’s all done.
Mac
First you’ll need to make sure you have a c-compiler on your system. In Terminal, enter:
xcode-select --install
After that, install homebrew from.
Update your PATH variable so that homebrew packages are used before system packages:
echo "export PATH=/usr/local/bin:/usr/local/sbin:$PATH" >> ~/.bashrc source ~/.bashrc
Install Python:
brew install python
And then make sure everything is updated:
brew update; brew upgrade python
After that’s done, just install Scrapy using pip:
>>
pip install Scrapy
Overview Of Scrapy, How The Pieces Fit Together, Parsers, Spiders, Etc
You will be writing a script called a ‘Spider’ for Scrapy to run, but don’t worry, Scrapy spiders aren’t scary at all despite their name. The only similarity Scrapy spiders and real spiders have are that they like to crawl on the web.
Inside the spider is a
class that you define that tells Scrapy what to do. For example, where to start crawling, the types of requests it makes, how to follow links on pages, and how it parses data. You can even add custom functions to process data as well, before outputting back into a file.
Writing Your First Spider, Write A Simple Spider To Allow For Hands-on Learning
To start our first spider, we need to first create a Scrapy project. To do this, enter this into your command line:
scrapy startproject oscars
This will create a folder with your project.
We’ll start with a basic spider. The following code is to be entered into a python script. Open a new python script in
/oscars/spiders and name it
oscars_spider.py
We’ll import Scrapy.
import scrapy
We then start defining our Spider class. First, we set the name and then the domains that the spider is allowed to scrape. Finally, we tell the spider where to start scraping from.
class OscarsSpider(scrapy.Spider): name = "oscars" allowed_domains = ["en.wikipedia.org"] start_urls = ['']
Next, we need a function which will capture the information that we want. For now, we’ll just grab the page title. We use CSS to find the tag which carries the title text, and then we extract it. Finally, we return the information back to Scrapy to be logged or written to a file.
def parse(self, response): data = {} data['title'] = response.css('title::text').extract() yield data
Now save the code in
/oscars/spiders/oscars_spider.py
To run this spider, simply go to your command line and type:
scrapy crawl oscars
You should see an output like this:
2019-05-02 14:39:31 [scrapy.utils.log] INFO: Scrapy 1.6.0 started (bot: oscars) ... 2019-05-02 14:39:32 [scrapy.core.engine] DEBUG: Crawled (200)
(referer: None) 2019-05-02 14:39:34 [scrapy.core.engine] DEBUG: Crawled (200) (referer: None) 2019-05-02 14:39:34 [scrapy.core.scraper] DEBUG: Scraped from <200> {'title': ['Academy Award for Best Picture - Wikipedia']} 2019-05-02 14:39:34 [scrapy.core.engine] INFO: Closing spider (finished) 2019-05-02 14:39:34 [scrapy.statscollectors] INFO: Dumping Scrapy stats: {'downloader/request_bytes': 589, 'downloader/request_count': 2, 'downloader/request_method_count/GET': 2, 'downloader/response_bytes': 74517, 'downloader/response_count': 2, 'downloader/response_status_count/200': 2, 'finish_reason': 'finished', 'finish_time': datetime.datetime(2019, 5, 2, 7, 39, 34, 264319), 'item_scraped_count': 1, 'log_count/DEBUG': 3, 'log_count/INFO':(2019, 5, 2, 7, 39, 31, 431535)} 2019-05-02 14:39:34 [scrapy.core.engine] INFO: Spider closed (finished)
Congratulations, you’ve built your first basic Scrapy scraper!
Full code:
import scrapy class OscarsSpider(scrapy.Spider): name = "oscars" allowed_domains = ["en.wikipedia.org"] start_urls = [""] def parse(self, response): data = {} data['title'] = response.css('title::text').extract() yield data
Obviously, we want it to do a little bit more, so let’s look into how to use Scrapy to parse data.
First, let’s get familiar with the Scrapy shell. The Scrapy shell can help you test your code to make sure that Scrapy is grabbing the data you want.
To access the shell, enter this into your command line:
scrapy shell “”
This will basically open the page that you’ve directed it to and it will let you run single lines of code. For example, you can view the raw HTML of the page by typing in:
print(response.text)
Or open the page in your default browser by typing in:
view(response)
Our goal here is to find the code that contains the information that we want. For now, let’s try to grab the movie title names only.
The easiest way to find the code we need is by opening the page in our browser and inspecting the code. In this example, I am using Chrome DevTools. Just right-click on any movie title and select ‘inspect’:
As you can see, the Oscar winners have a yellow background while the nominees have a plain background. There’s also a link to the article about the movie title, and the links for movies end in
film). Now that we know this, we can use a CSS selector to grab the data. In the Scrapy shell, type in:
response.css(r"tr[style='background:#FAEB86'] a[href*='film)']").extract()
As you can see, you now have a list of all the Oscar Best Picture Winners!
> response.css(r"tr[style='background:#FAEB86'] a[href*='film']").extract() ['<a href="/wiki/Wings_(1927_film)" title="Wings (1927 film)">Wings</a>', ... '<a href="/wiki/Green_Book_(film)" title="Green Book (film)">Green Book</a>', '<a href="/wiki/Jim_Burke_(film_producer)" title="Jim Burke (film producer)">Jim Burke</a>']
Going back to our main goal, we want a list of the Oscar winners for best picture, along with their director, starring actors, release date, and run time. To do this, we need Scrapy to grab data from each of those movie pages.
We’ll have to rewrite a few things and add a new function, but don’t worry, it’s pretty straightforward.
We’ll start by initiating the scraper the same way as before.
import scrapy, time class OscarsSpider(scrapy.Spider): name = "oscars" allowed_domains = ["en.wikipedia.org"] start_urls = [""]
But this time, two things will change. First, we’ll import
time along with
scrapy because we want to create a timer to restrict how fast the bot scrapes. Also, when we parse the pages the first time, we want to only get a list of the links to each title, so we can grab information off those pages instead.
def parse(self, response): for href in response.css(r"tr[style='background:#FAEB86'] a[href*='film)']::attr(href)").extract(): url = response.urljoin(href) print(url) req = scrapy.Request(url, callback=self.parse_titles) time.sleep(5) yield req
Here we make a loop to look for every link on the page that ends in
film) with the yellow background in it and then we join those links together into a list of URLs, which we will send to the function
parse_titles to pass further. We also slip in a timer for it to only request pages every 5 seconds. Remember, we can use the Scrapy shell to test our response.css fields to make sure we’re getting the correct data!
The real work gets done in our
parse_data function, where we create a dictionary called
data and then fill each key with the information we want. Again, all these selectors were found using Chrome DevTools as demonstrated before and then tested with the Scrapy shell.
The final line returns the data dictionary back to Scrapy to store.
Complete code:
import scrapy, time class OscarsSpider(scrapy.Spider): name = "oscars" allowed_domains = ["en.wikipedia.org"] start_urls = [""] def parse(self, response): for href in response.css(r"tr[style='background:#FAEB86'] a[href*='film)']::attr(href)").extract(): url = response.urljoin(href) print(url) req = scrapy.Request(url, callback=self.parse_titles) time.sleep(5) yield req
Sometimes we will want to use proxies as websites will try to block our attempts at scraping.
To do this, we only need to change a few things. Using our example, in our
def parse(), we need to change it to the following:
def parse(self, response): for href in (r"tr[style='background:#FAEB86'] a[href*='film)']::attr(href)").extract() : url = response.urljoin(href) print(url) req = scrapy.Request(url, callback=self.parse_titles) req.meta['proxy'] = "" yield req
This will route the requests through your proxy server.
Deployment And Logging, Show How To Actually Manage A Spider In Production
Now it is time to run our spider. To make Scrapy start scraping and then output to a CSV file, enter the following into your command prompt:
scrapy crawl oscars -o oscars.csv
You will see a large output, and after a couple of minutes, it will complete and you will have a CSV file sitting in your project folder.
Compiling Results, Show How To Use The Results Compiled In The Previous Steps
When you open the CSV file, you will see all the information we wanted (sorted out by columns with headings). It’s really that simple.
With data scraping, we can obtain almost any custom dataset that we want, as long as the information is publicly available. What you want to do with this data is up to you. This skill is extremely useful for doing market research, keeping information on a website updated, and many other things.
It’s fairly easy to set up your own web scraper to obtain custom datasets on your own, however, always remember that there might be other ways to obtain the data that you need. Businesses invest a lot into providing the data that you want, so it’s only fair that we respect their terms and conditions.
Additional Resources For Learning More About Scrapy And Web Scraping In General
- The Official Scrapy Website
- Scrapy’s GitHub Page
- “The 10 Best Data Scraping Tools and Web Scraping Tools,” Scraper API
- “5 Tips For Web Scraping Without Getting Blocked or Blacklisted,” Scraper API
- Parsel, a Python library to use regular expressions to extract data from HTML.
| https://www.smashingmagazine.com/2019/07/ultimate-guide-scalable-web-scrapers-scrapy/ | CC-MAIN-2019-47 | en | refinedweb |
Return the number of rows affected by a statement
#include <qdb/qdb.h> uint64_t qdb_rowchanges( qdb_hdt_t *hdl qdb_result_t *result );
qdb
This function returns the number of rows that were affected in a statement. It first looks in result (if the QDB_OPTION_ROW_CHANGES option has been set by qdb_setoption()), returning the number of rows for the statement that produced the result. If result is NULL, or QDB_OPTION_ROW_CHANGES is off, the function queries the database handle hdl and returns the information about the last executed statement.
If this function returns 0, check errno to make sure that it is EOK, indicating that no row was affected (you should set errno to 0 before calling this function if you want to distinguish between an error and 0 rows). If errno is not EOK then there was an error with the request.
QNX Neutrino
qdb_setoption(), qdb_statement() | http://www.qnx.com/developers/docs/6.5.0_sp1/topic/com.qnx.doc.qdb_en_dev_guide/api/qdb_rowchanges.html | CC-MAIN-2022-27 | en | refinedweb |
package Games::Dukedom; our $VERSION = 'v0.1.3'; use Storable qw( freeze thaw ); use Carp; use Games::Dukedom::Signal; use Moo 1.004003; use MooX::StrictConstructor; use MooX::ClassAttribute; use MooX::Struct -rw, Land => [ qw( +trades +spoils +price +sell_price +planted ) ], Population => [ qw( +starvations +levy +casualties +looted +diseased +deaths +births ) ], Grain => [ qw( +food +trades +seed +spoilage +wages +spoils +yield +expense +taxes ) ], War => [ qw( +first_strike +tension +desire +will +grain_damage +risk ) ]; # status codes use constant RUNNING => 0; use constant RETIRED => 1; use constant KINGDOM => 2; use constant QUIT_GAME => -1; use constant DEPOSED => -2; use constant ABOLISHED => -3; # magic numbers use constant TAX_RATE => .5; use constant MAX_YEAR => 45; use constant MIN_LAND => 45; use constant MIN_POPULATION => 33; use constant MIN_GRAIN => 429; use constant MAX_FOOD_BONUS => 4; use constant LABOR_CAPACITY => 4; use constant SEED_PER_HA => 2; use constant MAX_SALE => 4000; use constant MAX_SELL_TRIES => 3; use constant MIN_LAND_PRICE => 4; use constant MIN_EXPENSE => 429; use constant WAR_CONSTANT => 1.95; use constant UNREST_FACTOR => .85; use constant MAX_1YEAR_UNREST => 88; use constant MAX_TOTAL_UNREST => 99; my @steps = ( qw( _init_year _feed_the_peasants _starvation_and_unrest _purchase_land _war_with_the_king _grain_production _kings_levy _war_with_neigbor _population_changes _harvest_grain _update_unrest ) ); my @settable_steps = ( qw( _display_msg _feed_the_peasants _purchase_land _sell_land _king_wants_war _grain_production _kings_levy _first_strike _goto_war _quit_game ) ); my %traits = ( price => { q1 => 4, q2 => 7, }, yield => { q1 => 4, q2 => 8, }, spoilage => { q1 => 4, q2 => 6, }, levies => { q1 => 3, q2 => 8, }, war => { q1 => 5, q2 => 8, }, first_strike => { q1 => 3, q2 => 6, }, disease => { q1 => 3, q2 => 8, }, birth => { q1 => 4, q2 => 8, }, merc_quality => { q1 => 8, q2 => 8, }, ); my $fnr = sub { my ( $q1, $q2 ) = @_; return int( rand() * ( 1 + $q2 - $q1 ) ) + $q1; }; my $gauss = sub { my ( $q1, $q2 ) = @_; my $g0; my $q3 = &$fnr( $q1, $q2 ); if ( &$fnr( $q1, $q2 ) > 5 ) { $g0 = ( $q3 + &$fnr( $q1, $q2 ) ) / 2; } else { $g0 = $q3; } return $g0; }; class_has signal => ( is => 'ro', init_arg => undef, default => 'Games::Dukedom::Signal', handles => 'Throwable', ); has _base_values => ( is => 'ro', init_arg => undef, default => sub { my $base = {}; for ( keys(%traits) ) { $base->{$_} = &$gauss( $traits{$_}{q1}, $traits{$_}{q2} ); } return $base; }, ); has year => ( is => 'rwp', init_arg => undef, default => 0, ); has population => ( is => 'rwp', init_arg => undef, default => 100, ); has _population => ( is => 'ro', lazy => 1, clearer => 1, default => sub { Population->new; }, init_arg => undef, ); has grain => ( is => 'rwp', init_arg => undef, default => 4177, ); has _grain => ( is => 'ro', clearer => 1, lazy => 1, default => sub { Grain->new; }, init_arg => undef, ); has land => ( is => 'rwp', init_arg => undef, default => 600, ); has _land => ( is => 'ro', lazy => 1, clearer => 1, default => sub { Land->new; }, init_arg => undef, ); has land_fertility => ( is => 'ro', init_arg => undef, default => sub { { 100 => 216, 80 => 200, 60 => 184, 40 => 0, 20 => 0, 0 => 0, }; }, ); has _war => ( is => 'ro', lazy => 1, clearer => 1, default => sub { War->new; }, init_arg => undef, ); has yield => ( is => 'rwp', init_arg => undef, default => 3.95, ); has unrest => ( is => 'rwp', init_arg => undef, default => 0, ); has _unrest => ( is => 'ro', default => 0, init_arg => undef, ); has king_unrest => ( is => 'rwp', init_arg => undef, default => 0, ); has tax_paid => ( is => 'ro', init_arg => undef, default => 0, ); has _black_D => ( is => 'ro', init_arg => undef, default => 0, ); has input => ( is => 'rw', init_arg => undef, clearer => 1, default => undef, ); has _steps => ( is => 'lazy', init_arg => undef, clearer => 1, default => sub { [@steps] }, ); has status => ( is => 'rwp', init_arg => undef, default => RUNNING, ); has _msg => ( is => 'rw', init_arg => undef, clearer => 1, default => undef, ); has detail_report => ( is => 'ro', init_arg => undef, default => '', ); sub BUILD { my $self = shift; return; } # guarantee we have a clean input if needed. before throw => sub { my $self = shift; $self->clear_input; return; }; # intercept a "quit" request around input => sub { my $orig = shift; my $self = shift; my $input = $_[0] || ''; $self->_next_step('_quit_game') if $input =~ /^(?:q|quit)\s*$/i; return $self->$orig(@_); }; sub input_is_yn { my $self = shift; my $value = $self->input; chomp($value) if defined($value); return !!( defined($value) && $value =~ /^(?:y|n)$/i ); } sub input_is_value { my $self = shift; my $value = $self->input; chomp($value) if defined($value); return !!( defined($value) && ( $value =~ /^\d+$/ ) ); } sub play_one_year { my $self = shift; my $params = @_; return if $self->game_over; while ( @{ $self->_steps } ) { my $step = shift( @{ $self->_steps } ); $self->$step; $self->clear_input; } $self->_prep_detail_report(); $self->{tax_paid} += $self->_grain->taxes; $self->_clear_steps; $self->_clear_population; $self->_clear_grain; $self->_clear_land; $self->_clear_war; $self->_end_of_game_check; return; } sub game_over { my $self = shift; return !( $self->status == RUNNING ); } sub _next_step { my $self = shift; my $next = shift; croak "Illegal value for '_next_step': $next" unless grep( /^$next$/, @settable_steps); return unshift( @{ $self->_steps }, $next ); } sub _randomize { my $self = shift; my $trait = shift; return int( &$fnr( -2, 2 ) + $self->_base_values->{$trait} ); } sub _init_year { my $self = shift; ++$self->{year}; $self->{_unrest} = 0; $self->_land->{price} = int( ( 2 * $self->yield ) + $self->_randomize('price') - 5 ); $self->_land->{price} = MIN_LAND_PRICE if $self->_land->price < MIN_LAND_PRICE; $self->_land->{sell_price} = $self->_land->price; $self->{_msg} = $self->_summary_report; $self->{_msg} .= $self->_fertility_report; $self->_next_step('_display_msg'); return; } sub _display_msg { my $self = shift; # a Moo clearer returns the existing value, if any, like delete does. $self->throw( $self->_clear_msg ); } sub _summary_report { my $self = shift; my $msg = sprintf( "\nYear %d Peasants %d Land %d Grain %d Taxes %d\n", $self->year, $self->population, $self->land, $self->grain, $self->tax_paid ); return $msg; } sub _fertility_report { my $self = shift; my $msg = "Land Fertility:\n"; $msg .= " 100% 80% 60% 40% 20% Depl\n"; for ( 100, 80, 60, 40, 20, 0 ) { $msg .= sprintf( "%5d", $self->land_fertility->{$_} ); } $msg .= "\n"; return $msg; } sub _feed_the_peasants { my $self = shift; my $hint = ( $self->grain / $self->population ) < 11 ? $self->grain : 14; $self->_next_step('_feed_the_peasants') and $self->throw( msg => "Grain for food [$hint]: ", action => 'get_value', default => $hint, ) unless $self->input_is_value; my $food = $self->input; # shortcut $food *= $self->population if ( $food < 100 && $self->grain > $food ); if ( $food > $self->grain ) { $self->_next_step('_feed_the_peasants'); $self->throw( $self->_insufficient_grain('feed') ); } elsif (( ( $food / $self->population ) < 11 ) && ( $food != $self->grain ) ) { $self->{_unrest} += 3; $self->_next_step('_feed_the_peasants'); my $msg = "The peasants demonstrate before the castle\n"; $msg .= "with sharpened scythes\n\n"; $self->throw($msg); } $self->_grain->{food} = -$food; $self->{grain} += $self->_grain->{food}; return; } sub _starvation_and_unrest { my $self = shift; my $food = -$self->_grain->food; my $x1 = $food / $self->population; if ( $x1 < 13 ) { $self->_population->{starvations} = -int( ( $self->population - ( $food / 13 ) ) ); $self->{population} += $self->_population->starvations; } # only allow bonus for extra food up to 18HL/peasant $x1 -= 14; $x1 = MAX_FOOD_BONUS if $x1 > MAX_FOOD_BONUS; $self->{_unrest} = $self->_unrest - ( 3 * $self->_population->starvations ) - ( 2 * $x1 ); if ( $self->_population->starvations < 0 ) { $self->_msg("Some peasants have starved during the winter\n"); $self->_next_step('_display_msg'); } return ( ( $self->_unrest > 88 ) || ( $self->population < 33 ) ); } sub _purchase_land { my $self = shift; my $land = $self->_land; my $grain = $self->_grain; my $msg = ''; $msg .= sprintf( "Land to buy at %d HL/HA [0]: ", int( $land->{price} ) ); $self->_next_step('_purchase_land') and $self->throw( msg => $msg, action => 'get_value', default => 0 ) unless $self->input_is_value(); $self->_next_step('_sell_land') and return unless my $buy = $self->input; $self->_next_step('_purchase_land') and $self->throw( $self->_insufficient_grain('buy') ) if ( $buy * $land->price > $self->grain ); $self->land_fertility->{60} += $buy; $land->{trades} = $buy; $self->{land} += $buy; $grain->{trades} = -$buy * $land->{price}; $self->{grain} += $grain->{trades}; return; } sub _sell_land { my $self = shift; my $land = $self->_land; my $grain = $self->_grain; if ( $land->price - $land->sell_price > MAX_SELL_TRIES ) { $grain->{trades} = 0; $self->throw("Buyers have lost interest\n"); } my $price = --$land->{sell_price}; my $msg = sprintf( "Land to sell at %d HL/HA [0]: ", $price ); $self->_next_step('_sell_land') and $self->throw( msg => $msg, action => 'get_value', default => 0 ) unless $self->input_is_value(); return unless my $sold = $self->input; my $x1 = 0; for ( 100, 80, 60 ) { $x1 += $self->land_fertility->{$_}; } $self->{_msg} = undef; if ( $sold > $x1 ) { $self->_next_step('_display_msg'); $self->{_msg} = sprintf( "You only have %d HA. of good land\n", $x1 ); } elsif ( ( $grain->{trades} = $sold * $price ) > MAX_SALE ) { $self->_next_step('_display_msg'); $self->{_msg} = "No buyers have that much grain - sell less\n"; } return if $self->_msg; $land->{trades} = -$sold; my $valid = 0; my $sold_q; for ( 60, 80, 100 ) { $sold_q = $_; if ( $sold <= $self->land_fertility->{$_} ) { $valid = 1; last; } else { $sold -= $self->land_fertility->{$_}; $self->land_fertility->{$_} = 0; } } if ( !$valid ) { my $msg = "LAND SELLING LOOP ERROR - CONTACT PROGRAM AUTHOR IF\n"; $msg .= "ERROR IS NOT YOURS IN ENTERING PROGRAM,\n"; $msg .= "AND SEEMS TO BE FAULT OF PROGRAM'S LOGIC.\n"; die $msg; } $self->land_fertility->{$sold_q} -= $sold; $self->{land} += $land->trades; $self->_set_status(ABOLISHED) if $self->land < 10; $msg = ''; if ( ( $price < MIN_LAND_PRICE ) && $sold ) { $grain->{trades} = int( $grain->{trades} / 2 ); $msg = "\nThe High King appropriates half your earnings\n"; $msg .= "as punishment for selling at such a low price\n"; } $self->{grain} += $grain->{trades}; $self->throw($msg) if $msg; return; } sub _war_with_the_king { my $self = shift; $self->_king_wants_war if $self->king_unrest > 0; return if $self->king_unrest > -2; my $mercs = int( $self->grain / 100 ); my $msg = "\nThe King's army is about to attack your duchy\n"; $msg .= sprintf( "You have hired %d foreign mercenaries\n", $mercs ); $msg .= "at 100 HL. each (payment in advance)\n\n"; # assuming a population > 200 at the time of your revolt, # the C source # i ported from allowed one to win with as few as 5 mercs. # if ( ( $self->grain * $mercs ) + $self->population > 2399 ) { # # the Java source changed it so it took significantly more, about 275 but # was still a fixed value. # if ( ( 8 * $mercs ) + $self->population > 2399 ) { # # i've added an element of chance. again, assuming a populaton of 200, it # now requires anywhere from 219 to 366 mercs to win depending on the # quality of merc you hire. this means you must have at least 22,000 in # grain to win, and as much as 37,000 if your mercs suck. if ( ( int( $self->_randomize('merc_quality') ) * $mercs ) + $self->population > 2399 ) { $msg .= "Wipe the blood from the crown - you are now High King!\n\n"; $msg .= "A nearby monarchy threatens war; "; $msg .= "how many .........\n\n\n\n"; $self->_set_status(KINGDOM); } else { $msg .= "The placement of your head atop the castle gate signifies\n"; $msg .= "that the High King has abolished your Ducal right\n\n"; $self->_set_status(ABOLISHED); } $self->{_msg} = $msg; $self->{_steps} = ['_display_msg']; return; } sub _king_wants_war { my $self = shift; return unless $self->king_unrest > 0; my $msg = "\nThe King demands twice the royal tax in the\n"; $msg .= 'hope of provoking war. Will you pay? [Y/n]: '; $self->_next_step('_king_wants_war') and $self->throw( msg => $msg, action => 'get_yn', default => 'Y' ) unless $self->input_is_yn; my $ans = $self->input; $ans ||= 'Y'; $self->_set_king_unrest( ( $ans =~ /^n/i ) ? -1 : 2 ); return; } sub _grain_production { my $self = shift; my $done = 0; my $pop_plant = $self->population * LABOR_CAPACITY; my $grain_plant = int( $self->grain / SEED_PER_HA ); my $max_grain_plant = $grain_plant > $self->land ? $self->land : $grain_plant; my $max_plant = $pop_plant > $max_grain_plant ? $max_grain_plant : $pop_plant; my $msg = ''; $msg .= sprintf( "Land to plant [%d]: ", $max_plant ); $self->_next_step('_grain_production') and $self->throw( msg => $msg, action => 'get_value', default => $max_plant ) unless $self->input_is_value(); my $plant = $self->input || $max_plant; my $grain = $self->_grain; $msg = ''; if ( $plant > $self->land ) { $msg = "You don't have enough land\n"; $msg .= sprintf( "You only have %d HA. of land left\n", $self->land ); } if ( $plant > ($pop_plant) ) { $msg = "You don't have enough peasants\n"; $msg .= sprintf( "Your peasants can only plant %d HA. of land\n", $pop_plant ); } $grain->{seed} = -( SEED_PER_HA * $plant ); if ( -$grain->seed > $self->grain ) { $msg = $self->_insufficient_grain('plant'); } if ($msg) { $self->_next_step('_grain_production'); $self->throw($msg); } $grain->{yield} = $plant; $self->_land->{planted} = $plant; $self->{grain} += $grain->seed; my $tmp_quality = $self->_update_land_tables($plant); $self->_crop_yield_and_losses($tmp_quality); return; } sub _update_land_tables { my $self = shift; my $plant = shift; my $valid = 0; my %tmp_quality = ( 100 => 0, 80 => 0, 60 => 0, 40 => 0, 20 => 0, 0 => 0, ); my $quality = $self->land_fertility; my $qfactor; for (qw( 100 80 60 40 20 0 )) { $qfactor = $_; if ( $plant <= $quality->{$qfactor} ) { $valid = 1; last; } else { $plant -= $quality->{$qfactor}; $tmp_quality{$qfactor} = $quality->{$qfactor}; $quality->{$qfactor} = 0; } } if ( !$valid ) { warn "LAND TABLE UPDATING ERROR - PLEASE CONTACT PROGRAM AUTHOR\n"; warn "IF ERROR IS NOT A FAULT OF ENTERING THE PROGRAM, BUT RATHER\n"; warn "FAULT OF THE PROGRAM LOGIC.\n"; exit(1); } $tmp_quality{$qfactor} = $plant; $quality->{$qfactor} -= $plant; $quality->{100} += $quality->{80}; $quality->{80} = 0; for ( 60, 40, 20, 0 ) { $quality->{ $_ + 40 } += $quality->{$_}; $quality->{$_} = 0; } for ( 100, 80, 60, 40, 20 ) { $quality->{ $_ - 20 } += $tmp_quality{$_}; } $quality->{0} += $tmp_quality{0}; return \%tmp_quality; } sub _crop_yield_and_losses { my $self = shift; my $tmp_q = shift; $self->{_msg} = ''; $self->{yield} = $self->_randomize('yield') + 3; if ( !( $self->year % 7 ) ) { $self->{_msg} .= "Seven year locusts\n"; $self->{yield} /= 2; } my $x1 = 0; for ( 100, 80, 60, 40, 20 ) { $x1 += $tmp_q->{$_} * ( $_ / 100 ); } my $grain = $self->_grain; if ( $self->_land->planted == 0 ) { $self->{yield} = 0; } else { $self->{yield} = int( $self->yield * ( $x1 / $self->_land->planted ) * 100 ) / 100; } $self->{_msg} .= sprintf( "Yield = %0.2f HL./HA.\n", $self->yield ); $x1 = $self->_randomize('spoilage') + 3; unless ( $x1 < 9 ) { $grain->{spoilage} = -int( ( $x1 * $self->grain ) / 83 ); $self->{grain} += $grain->{spoilage}; $self->{_msg} .= "Rats infest the grainery\n"; } $self->_next_step('_display_msg'); return; } sub _kings_levy { my $self = shift; return if ( $self->population < 67 ) || ( $self->king_unrest == -1 ); # there is an edge case where entering an invalid answer might allow # one to avoid this, but ... who cares my $x1 = $self->_randomize('levies'); return if $x1 > ( $self->population / 30 ); my $msg = sprintf( "\nThe High King requires %d peasants for his estates ", int($x1) ); $msg .= "and mines.\n"; $msg .= sprintf( "Will you supply them or pay %d ", int( $x1 * 100 ) ); $msg .= "HL. of grain instead [Y/n]: "; $self->_next_step('_kings_levy') and $self->throw( msg => $msg, action => 'get_yn', default => 'Y' ) unless $self->input_is_yn(); if ( $self->input =~ /^n/i ) { $self->_grain->{taxes} = -100 * $x1; $self->{grain} += $self->_grain->{taxes}; } else { $self->_population->{levy} = -int($x1); $self->{population} += $self->_population->{levy}; } return; } # TODO: find names for the "magic numbers" and change them to constants sub _war_with_neigbor { my $self = shift; if ( $self->king_unrest == -1 ) { $self->{_msg} = "\nThe High King calls for peasant levies\n"; $self->{_msg} .= "and hires many foreign mercenaries\n"; $self->{king_unrest} = -2; } else { my $war = $self->_war; # are you worth coming after? $war->{tension} = int( 11 - ( 1.5 * $self->yield ) ); $war->{tension} = 2 if ( $war->tension < 2 ); if ( $self->king_unrest || ( $self->population <= 109 ) || ( ( 17 * ( $self->land - 400 ) + $self->grain ) <= 10600 ) ) { $war->{desire} = 0; } else { $self->{_msg} = "\nThe High King grows uneasy and may\n"; $self->{_msg} .= "be subsidizing wars against you\n"; $war->{tension} += 2; $war->{desire} = $self->year + 5; } $war->{risk} = int( $self->_randomize('war') ); $self->_next_step('_first_strike') if $war->tension > $war->risk; $war->{first_strike} = int( $war->{desire} + 85 + ( 18 * $self->_randomize('first_strike') ) ); } $self->_next_step('_display_msg') if $self->_msg; return; } sub _first_strike { my $self = shift; my $war = $self->_war; $war->{will} = 1.2 - ( $self->_unrest / 16 ); my $resistance = int( $self->population * $war->will ) + 13; my $msg = "A nearby Duke threatens war; Will you attack first [y/N]? "; $self->_next_step('_first_strike') and $self->throw( msg => $msg, action => 'get_yn', default => 'N' ) unless $self->input_is_yn(); my $population = $self->_population; $self->{_msg} = ''; if ( $self->input !~ /^n/i ) { if ( $war->{first_strike} >= $resistance ) { $self->_next_step('_goto_war'); $self->{_msg} = "First strike failed - you need professionals\n"; $population->{casualties} = -$war->risk - $war->tension - 2; $war->{first_strike} += ( 3 * $population->casualties ); } else { $self->{_msg} = "Peace negotiations were successful\n"; $population->{casualties} = -$war->tension - 1; $war->{first_strike} = 0; } $self->{population} += $population->casualties; if ( $war->first_strike < 1 ) { $self->{_unrest} -= ( 2 * $population->casualties ) + ( 3 * $population->looted ); } } else { $self->_next_step('_goto_war'); } $self->_next_step('_display_msg') if $self->_msg; return; } sub _goto_war { my $self = shift; my $possible = int( $self->grain / 40 ); $possible = 75 if $possible > 75; $possible = 0 if $possible < 0; my $msg = "Hire how many mercenaries at 40 HL each [$possible]? "; $self->_next_step('_goto_war') and $self->throw( msg => $msg, action => 'get_value', default => $possible ) unless $self->input_is_value(); my $hired = $self->input || $possible; if ( $hired > 75 ) { my $msg = "There are only 75 mercenaries available for hire\n"; $self->_next_step('_goto_war'); $self->throw($msg); } my $war = $self->_war; my $land = $self->_land; my $resistance = int( ( $self->population * $war->will ) + ( 7 * $hired ) + 13 ); $war->{desire} = int( $war->desire * WAR_CONSTANT ); my $x6 = $war->desire - ( 4 * $hired ) - int( $resistance / 4 ); $war->{desire} = $resistance - $war->desire; $land->{spoils} = int( 0.8 * $war->desire ); if ( -$land->spoils > int( 0.67 * $self->land ) ) { $self->{_steps} = []; $self->_set_status(ABOLISHED); my $msg = "You have been overrun and have lost the entire Dukedom\n"; $msg .= "The placement of your head atop the castle gate\n"; $msg .= "signifies that "; $msg .= "the High King has abolished your Ducal right\n\n"; $self->throw($msg); } my $x1 = $land->spoils; my $fertility = $self->land_fertility; for ( 100, 80, 60 ) { my $x3 = int( $x1 / ( 3 - ( 5 - ( $_ / 20 ) ) ) ); if ( -$x3 <= $fertility->{$_} ) { $resistance = $x3; } else { $resistance = -$fertility->{$_}; } $fertility->{$_} += $resistance; $x1 = $x1 - $resistance; } for ( 40, 20, 0 ) { if ( -$x1 <= $fertility->{$_} ) { $resistance = $x1; } else { $resistance = -$fertility->{$_}; } $fertility->{$_} += $resistance; $x1 = $x1 - $resistance; } my $grain = $self->_grain; $msg = ''; if ( $land->spoils < 399 ) { if ( $war->desire >= 0 ) { $msg = "You have won the war\n"; $war->{grain_damage} = 0.67; $grain->{spoils} = int( 1.7 * $land->spoils ); $self->{grain} += $grain->spoils; } else { $msg = "You have lost the war\n"; $war->{grain_damage} = int( ( $grain->yield / $self->land ) * 100 ) / 100; } if ( $x6 <= 9 ) { $x6 = 0; } else { $x6 = int( $x6 / 10 ); } } else { $msg = "You have overrun the enemy and annexed his entire Dukedom\n"; $grain->{spoils} = 3513; $self->{grain} += $grain->spoils; $x6 = -47; $war->{grain_damage} = 0.55; if ( $self->king_unrest <= 0 ) { $self->{king_unrest} = 1; $msg .= "The King fears for his throne and\n"; $msg .= "may be planning direct action\n"; } } $x6 = $self->population if ( $x6 > $self->population ); my $population = $self->_population; $population->{casualties} -= $x6; $self->{population} -= $x6; $grain->{yield} += int( $war->grain_damage * $land->spoils ); $x6 = 40 * $hired; if ( $x6 <= $self->grain ) { $grain->{wages} = -$x6; # what is P[5] (looted) in this case? } else { $grain->{wages} = -$self->grain; $population->{looted} = -int( ( $x6 - $self->grain ) / 7 ) - 1; $msg .= "There isn't enough grain to pay the mercenaries\n"; } $self->{grain} += $grain->wages; --$self->{population} if ( -$population->looted > $self->population ); $self->{population} += $population->looted; $self->{land} += $land->spoils; $self->{_unrest} -= ( 2 * $population->casualties ) - ( 3 * $population->looted ); $self->_next_step('_display_msg') if $self->{_msg} = $msg; return; } sub _population_changes { my $self = shift; my $x1 = $self->_randomize('disease'); my $population = $self->_population; my $x2; if ( $x1 <= 3 ) { if ( $x1 != 1 ) { $self->{_msg} = "A POX EPIDEMIC has broken out\n"; $self->_next_step('_display_msg'); $x2 = $x1 * 5; $population->{diseased} = -int( $self->population / $x2 ); $self->{population} += $population->diseased; } elsif ( $self->_black_D <= 0 ) { $self->{_msg} = "The BLACK PLAGUE has struck the area\n"; $self->_next_step('_display_msg'); $self->{_black_D} = 13; $x2 = 3; $population->{diseased} = -int( $self->population / $x2 ); $self->{population} += $population->diseased; } } $x1 = $population->looted ? 4.5 : $self->_randomize('birth') + 4; $population->{births} = int( $self->population / $x1 ); $population->{deaths} = int( 0.3 - ( $self->population / 22 ) ); $self->{population} += $population->deaths + $population->births; --$self->{_black_D}; return; } sub _harvest_grain { my $self = shift; my $grain = $self->_grain; $grain->{yield} = int( $self->yield * $self->_land->planted ); $self->{grain} += $grain->yield; my $x1 = $grain->yield - 4000; $grain->{expense} = -int( 0.1 * $x1 ) if $x1 > 0; $grain->{expense} -= MIN_EXPENSE; $self->{grain} += $grain->expense; # you've already told the King what to do with his taxes, he's coming # to collect them (and more) in person now. return if $self->king_unrest < 0; my $tax_rate = $self->king_unrest >= 2 ? TAX_RATE * 2 : TAX_RATE; $x1 = -int( $self->land * $tax_rate ); if ( -$x1 > $self->grain ) { $self->{_msg} = "You have insufficient grain to pay the royal tax\n"; $self->{_msg} .= "the High King has abolished your Ducal right\n\n"; $self->_next_step('_display_msg'); $self->_set_status(ABOLISHED); return 1; } $grain->{taxes} += $x1; $self->{grain} += $x1; return; } sub _update_unrest { my $self = shift; $self->{unrest} = int( $self->unrest * UNREST_FACTOR ) + $self->_unrest; return; } sub _quit_game { my $self = shift; # empty the stack, don't clear it or it will re-initialize! $self->{_steps} = []; $self->_set_status(QUIT_GAME); return; } sub _end_of_game_check { my $self = shift; my $msg = ''; if ( $self->status eq QUIT_GAME ) { $msg = "\nYou have conceded the game\n\n"; } elsif (( $self->grain < MIN_GRAIN ) || ( $self->_unrest > MAX_1YEAR_UNREST ) || ( $self->unrest > MAX_TOTAL_UNREST ) ) { $msg = "\nThe peasants tire of war and starvation\n"; $msg .= "You are deposed!\n\n"; $self->_set_status(DEPOSED); } elsif ( $self->population < MIN_POPULATION ) { $msg = "You have so few peasants left that\n"; $msg .= "the High King has abolished your Ducal right\n\n"; $self->_set_status('ABOLISHED'); } elsif ( $self->land < MIN_LAND ) { $msg = "You have so little land left that\n"; $msg .= "the High King has abolished your Ducal right\n\n"; $self->_set_status(ABOLISHED); } elsif ( $self->year >= MAX_YEAR && !$self->king_unrest ) { $msg = "You have reached the age of mandatory retirement\n\n"; $self->_set_status(RETIRED); } $self->throw($msg) if $self->game_over; return; } sub _insufficient_grain { my $self = shift; my $action = shift; my %msgs = ( feed => sprintf( "You have %d HL. of grain left,\n", $self->grain ), buy => sprintf( "Enough to buy %d HA. of land\n", int( $self->grain / $self->_land->{price} ) ), plant => sprintf( "Enough to plant %d HA. of land\n\n", int( $self->grain / SEED_PER_HA ) ), ); my $msg = "You don't have enough grain\n"; $msg .= $msgs{$action}; return $msg; } sub _prep_detail_report { my $self = shift; my $msg = "\n"; for ( sort( keys( %{ $self->_population } ) ) ) { $msg .= sprintf( "%-20.20s %d\n", $_, $self->_population->$_ ); } $msg .= sprintf( "%-20.20s %d\n\n", "Peasants at end", $self->population ); for ( sort( keys( %{ $self->_land } ) ) ) { $msg .= sprintf( "%-20.20s %d\n", $_, $self->_land->$_ ); } $msg .= sprintf( "%-20.20s %d\n\n", "Land at end", $self->land ); for ( sort( keys( %{ $self->_grain } ) ) ) { $msg .= sprintf( "%-20.20s %d\n", $_, $self->_grain->$_ ); } $msg .= sprintf( "%-20.20s %d\n\n", "Grain at end", $self->grain ); for ( sort( keys( %{ $self->_war } ) ) ) { $msg .= sprintf( "%-20.20s %d\n", $_, $self->_war->$_ ); } $self->{detail_report} = $msg; return; } 1; __END__ =pod =head1 NAME Games::Dukedom - The classic big-iron game =head1 SYNOPSIS use Games::Dukedom; my $game = Games::Dukedom->new(); =head1 C<play_one_year>. =head1 CONSTRUCTOR One begins the game by calling the expected C<new> method like so: my $game = Games::Dukedom->new(); It currently does not take any parameters. =head2 ATTRIBUTES All attributes, except for C<input>, have read-only accessors. It should be noted that the values in the attributes will probably not be of much use to a game implementation other than to provide specialized reports if so desired, hence the reason for being read-only (except for the obvious case of C<input>). On the other hand, they do provide the current environment for a given year of play and B<must> be preserved at all times. It is anticipated that a stateless environment such as a CGI script will need to save state in some fashion when requesting input and then restore it prior to applying the input and re-entering the state-machine. =over 4 =item input (read-write) This attribute should hold the latest value requested by the state-machine. It will recognize the values 'q' and 'quit' (case-insensitive) and set the game status to C<QUIT_GAME> if either of those are submitted. =item grain The current amount of grain on hand. =item king_unrest Used to indicate the level of the King's mistrust. =item land The current amount of land on hand. =item. =item population The current number of peasants in the Dukedom. =item status Indicates that the game is either C<RUNNING> or in one of the conditions that indicate that the end of the game has been reached. A "win" is indicated by a positive value, a "loss" by a negative one. =over 4 =item 2 - It's GOOD to be the King! =item 1 - You have retired =item 0 - Game is running =item -1 - You have abandoned the game =item -2 - You have been deposed =item -3 - Don't mess with the King! =back =item unrest Holds the cummulative population unrest factor. There is also an annual unrest factor that gets reset at the start of each game year. The two are relatively independent in that an excess of either one can cause you to be deposed and end the game. =item tax_paid Total amount of taxes paid to the King since the beginnig of the game. =item year The current game year. The will automatically end with you being forced into retirement at the end of 45 years unless some other cause occurs first. NOTE: This will be ignored if a state of war currently exists between you and the King that must be resolved. =item yield The amound of grain produced in the prior yield expressed as HL/HA. =back =head1 METHODS =head2 C<msg> and C<action> attributes. =head2 game_over Boolean that indicates that current game is over and further play is not possible. Check C<status> for reason if desired. =head2 input_is_yn Boolean that returns C<1> if the current content of C<< $game->input >> is either "Y" or "N" (case insensitive) or C<undef> otherwise. =head2 input_is_value Boolean that returns C<1> if the current content of C<< $game->input >> is "0" or a positive integer and C<undef> otherwise. =head1 SEE ALSO L<Games::Dukedom::Signal> This package is based on the logic found in this C code, which appears to have been derived from an older source written in Basic: L<> A good description of the goals of the game and how to play is here: L<> and here: L<> =head1 BUGS Seriously? Look at the version number. =head1 AUTHOR Jim Bacon, E<lt>[email protected]<gt> =head1 COPYRIGHT AND LICENSE Copyright (C) 2014 by Jim Bacon This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself, either Perl version 5.8 or, at your option, any later version of Perl 5 you may have available. =cut | https://web-stage.metacpan.org/release/BOFTX/Games-Dukedom-v0.1.3/source/lib/Games/Dukedom.pm | CC-MAIN-2022-27 | en | refinedweb |
Powerful one-liners can be just as powerful as a long and tedious program written in another language designed to do the same thing. In other languages (think: Java) this would be nearly impossible, but in Python, it's a lot easier to do. The trick is to think of something that will "do a lot with a little." Most importantly, reading and writing about Python one-liners (e.g., in this post) is a lot of fun! There's even a whole subculture around who can write the shortest code for a given problem.
It would be awesome if this page expanded to the point where it needs some sort of organization system. (Edit: The one-liners are now sorted more or less by ease-of-understanding -- from simple to hard. Please use a "sorted insert" for your new one-liner.)
The source code is contributed from different Python coders --- Thanks to all of them! Special thanks to the early contributor JAM.
Of course, there is debate on whether one-liners are even Pythonic. As a rule of thumb: if you use one-liners that are confusing, difficult to understand, or to show off your skills, they tend to be Unpythonic. However, if you use well-established one-liner tricks such as list comprehension or the ternary operator, they tend to be Pythonic.
So, use your one-liner superpower wisely!
Free Python One-Liners Learning Resources
Free ''Python One-Liners'' videos & book resources
Collection of ''One-Liners'' with interactive shell
Book ''Python One-Liners''
Interesting Quora Thread ''Python One-Liner''
Python One-Line X - How to accomplish different tasks in a single line
Subreddit '''Python One-Liners'''
Github '''Python One-Liners''' - Share your own one-liners with the community
Overview: 10 one-liners that fit into a tweet
I visited this page oftentimes and I loved studying the one-liners presented above. Thanks for creating this awesome resource, JAM, and RJW!
Because I learned a lot from studying the one-liners, I thought why not revive the page (after almost ten years since the last change happened)?
After putting a lot of effort into searching the web for inspiration, I created the following ten one-liners. Some of them are more algorithmic (e.g. Quicksort). Some day, I will add a detailed explanation here - but for now, you can read this blog article to find explanations.
1 # Palindrome Python One-Liner 2 phrase.find(phrase[::-1]) 3 4 # Swap Two Variables Python One-Liner 5 a, b = b, a 6 7 # Sum Over Every Other Value Python One-Liner 8 sum(stock_prices[::2]) 9 10 # Read File Python One-Liner 11 [line.strip() for line in open(filename)] 12 13 # Factorial Python One-Liner 14 reduce(lambda x, y: x * y, range(1, n+1)) 15 16 # Performance Profiling Python One-Liner 17 python -m cProfile foo.py 18 19 # Superset Python One-Liner 20 lambda l: reduce(lambda z, x: z + [y + [x] for y in z], l, [[]]) 21 22 # Fibonacci Python One-Liner 23 lambda x: x if x<=1 else fib(x-1) + fib(x-2) 24 25 # Quicksort Python One-liner 26 lambda L: [] if L==[] else qsort([x for x in L[1:] if x< L[0]]) + L[0:1] + qsort([x for x in L[1:] if x>=L[0]]) 27 28 # Sieve of Eratosthenes Python One-liner 29 reduce( (lambda r,x: r-set(range(x**2,n,x)) if (x in r) else r), range(2,int(n**0.5)), set(range(2,n)))
Find All Indices of an Element in a List
Say, you want to do the same as the list.index(element) method but return all indices of the element in the list rather than only a single one.
In this one-liner, you’re looking for element 'Alice' in the list lst = [1, 2, 3, 'Alice', 'Alice'] so it even works if the element is not in the list (unlike the list.index() method).
echo unicode character:
python -c "print unichr(234)"
This script echos "ê"
Reimplementing cut
Print every line from an input file but remove the first two fields.
python -c "import sys;[sys.stdout.write(' '.join(line.split(' ')[2:])) for line in sys.stdin]" < input.txt
Alternative (shorter, more functional version):
f = lambda l: reduce(lambda z, x: z + [y + [x] for y in z], l, [[]])
Terabyte to Bytes
Want to know many bytes a terabyte is? If you know further abbreviations, you can extend the list.
import pprint;pprint.pprint(zip(('Byte', 'KByte', 'MByte', 'GByte', 'TByte'), (1 << 10*i for i in range(5))))
Largest 8-Bytes Number
And what's the largest number that can be represented by 8 Bytes?
print '\n'.join("%i Byte = %i Bit = largest number: %i" % (j, j*8, 256**j-1) for j in (1 << i for i in range(8)))
Cute, isn't);"
Cramming Python into Makefiles
A related issue is embedding Python into a Makefile. I had a really long script that I was trying to cram into a makefile so I automated the process:
1 import sys,re 2 3 def main(): 4 fh = open(sys.argv[1],'r') 5 lines = fh.readlines() 6 print '\tpython2.2 -c "`printf \\"if 1:\\n\\' 7 for line in lines: 8 line = re.sub('[\\\'\"()]','\\\g<0>',line) 9 # grab leading white space (should be multiples of 4) and makes them into 10 # tabs 11 wh_spc_len = len(re.match('\s*',line).group()) 12 13 sys.stdout.write('\t') 14 sys.stdout.write(wh_spc_len/4*'\\t'+line.rstrip().lstrip()) 15 sys.stdout.write('\\n\\\n') 16 print '\t\\"`"' 17 18 if __name__=='__main__': 19 main()
This script generates a "one-liner" from make's point of view.
Sony's Open Source command-line tool for performing python one-liners using unix-like pipes
They call it "The Pyed Piper" or pyp. It's pretty similar to the -c way of executing python, but it imports common modules and has its the username and filename its shortcut w, which both represent a list based on splitting each line on whitespace (whitespace = w = p.split()). The other functions and selection techniques are all standard Python. Notice the pipes ("|") are inside the pyp command.
Contributed Code
JAM/Code/PlatformFinder - This program tells you what platform you are using.
JAM/Code/ComPYiler - This program compiles every .py file in the Python directory.
Powerful Python One-Liners/Hostname - This program tells you what your hostname is. | https://wiki.python.org/moin/Powerful%20Python%20One-Liners | CC-MAIN-2022-27 | en | refinedweb |
Hello,
Newbie to Processing, and coding in general here. I am working on a project to control a 12v motor from a button on a sim racing steering wheel. The motor will be powered off most of the time, but I want it to activate when I press a specific button for the duration of the press. The below code is what I have so far, and it works with my Dualshock 4 controller.
import processing.serial.*; import net.java.games.input.*; import org.gamecontrolplus.*; import org.gamecontrolplus.gui.*; ControlIO control; Configuration config; ControlDevice gpad; Serial MySerial; void setup() { control = ControlIO.getInstance(this); gpad = control.filter(GCP.GAMEPAD).getMatchedDevice("Gamepad"); size(400, 600); MySerial = new Serial(this, "COM5", 9600); } void draw() { background(255, 0, 0); if (gpad.getButton("ACTIVATE").pressed()) { MySerial.write(1); } else { MySerial.write(0); } }
I do get the exact error message below every time I run the script but otherwise it works as intended.
Failed to initialize device ITE Device(8595) because of: java.io.IOException: Failed to acquire device (8007001e) Failed to initialize device ITE Device(8595) because of: java.io.IOException: Failed to acquire device (8007001e)
And the real trouble comes with the fact that the Dualshock is the only game controller device that I can get to work. Whenever I try my steering wheel or button box they do not work. I get the same error messages, but the other devices do nothing, and send nothing into serial monitor whereas the Dualshock will.
I have tried calling the steering every way I know how, including trying to call a specific setup file. But for example this is how I’m currently trying to call it, and I have triple checked to ensure this is how the wheel is identified in Processing/GCP.
ControlIO control; ControlDevice device; ControlButton ACTIVATE; Serial MySerial; void setup() { control = ControlIO.getInstance(this); device = control.getDevice("Thrustmaster Advanced Mode Racer"); size(400, 600); MySerial = new Serial(this, "COM5", 9600); }
Does anyone have any idea why my Dualshock will work but other peripherals can’t be initialized? The Dualshock is the last controller I would want to do this function. Any help would be greatly appreciated! | https://discourse.processing.org/t/issues-with-game-control-plus-processing-arduino/36691 | CC-MAIN-2022-27 | en | refinedweb |
Crypto Zombies (3) — ERC721 & Crypto-Collectibles
Token
You can think of it as a crypto asset. NFT is also a token. A token is one of the smart contracts that follow some common rules. This introduces us to a useful feature: we can effortlessly interact with any tokens that follow the same protocol.
Let me borrow some examples from Ethereum.org.
Tokens can represent virtually anything in Ethereum:
reputation points in an online platform, skills of a character in a game, lottery tickets, financial assets like a share in a company, a fiat currency like USD, an ounce of gold, and more…
ERC20.
It is a standard widely used across all Ethereum apps.
The basic functions include
- total supply
- balance of
- allowance
- transfer
- approve
- transfer from
Building an app that’s compatible with one ERC20 token means it can basically interact with any other tokens with the same protocol too.
ERC721
When building a zombie game, however, we’d like to implement logic that allows us to trade zombies. Yet a zombie is not divisible like cryptocurrency. This is where ERC721 comes into play. It’s simply a protocol for NFT collectables.
To use it, you simply copy and paste the code for erc721.
pragma solidity >=0.5.0 <0.6.0;contract ERC721 {event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);function balanceOf(address _owner) external view returns (uint256);function ownerOf(uint256 _tokenId) external view returns (address);function transferFrom(address _from, address _to, uint256 _tokenId) external payable;function approve(address _approved, uint256 _tokenId) external payable;}
erc721.sol just has a list of functions. We import the file, inherit the contract, and implement our custom functions.
Transfer Logic
There are two ways to implement it.
The first one is to simply use
transferFrom. The other way is to use
approve to specify who can take your particular token from your account.
mapping (uint => address) zombieApprovals;function _transfer(uint _from, uint _to, uint _tokenId) private {
ownerZombieCount[_from]--;
ownerZombieCount[_to]++;
zombieToOwner[_tokenId] = _to;
emit Transfer(_from, _to, _tokenId);
}function transferFrom(uint _from, uint _to, uint _tokenId) external payable {
require(msg.sender == zombieToOwner[_tokenId] || msg.sender == zombieApprovals[_tokenId]);
_transfer(_from, _to, _tokenId);
}function approve(uint _approved, uint _tokenId) external payable onlyOwnerOf(_tokenId) {
zombieApprovals[_tokenId] = _approved;
emit Approval(_approved, _tokenId);
}
Prevent overflow and underflow
Use
SafeMath here. I’m not sure about it, but I think I can later install the package instead of copy-pasting it. Anyways, for now, just paste the code in another file called
safemath.sol.
For
uint8 , the largest number you can have is 2⁸ = 255. When you add 1 to this number, you surprisingly get 0. To avoid this issue, we use
SafeMath .
import "./simplemath.sol"contract Number {
using SafeMath for uint256; uint counter = 0;
function increment() external {
counter = counter.add(1);
}
}
What if you also want to cover
uint32 ? You should define a new library called
SafeMath32 like this:
library SafeMath32 {
...
}
and use it.
import "./simplemath.sol"contract Number {
using SafeMath for uint256;
using SafeMath32 for uint32; uint counter = 0;
function increment() external {
counter = counter.add(1);
}
} | https://medium.com/lukeleeai/crypto-zombies-3-erc721-crypto-collectibles-4caf8e05eda4?source=read_next_recirc---------1---------------------40e14065_d6c9_4d0e_ae72_3a4854218b49------- | CC-MAIN-2022-27 | en | refinedweb |
30681/concern-and-cross-cutting-concern.
Hope this helps!
Enroll in Spring course online to learn more about it.
Thanks!
Below are the various advices available in AOP:
Before: These types ...READ MORE
You can use this method:
String[] strs = ...READ MORE
import java.io.BufferedWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
public class WriteFiles{
...READ MORE
Whenever you require to explore the constructor ...READ MORE
You can go to maven repositories ...READ MORE
Some of the Spring annotations that I ...READ MORE
To solve your ERROR, I would suggest ...READ MORE
You don't need @EnableJpaRepositories because your package ...READ MORE
By default, Annotation wiring is not turned ...READ MORE
Configuration metadata can be provided to Spring container in ...READ MORE
OR
At least 1 upper-case and 1 lower-case letter
Minimum 8 characters and Maximum 50 characters
Already have an account? Sign in. | https://www.edureka.co/community/30681/concern-and-cross-cutting-concern-in-spring-aop?show=53573 | CC-MAIN-2022-27 | en | refinedweb |
w . j av a 2 s . co m*/ import android.content.ContentValues; import com.ianhanniballake.recipebook.provider.RecipeContract; /** * Class that manages the information associated with an instruction */ public class Instruction { private String instruction; /** * Creates a new, empty instruction */ public Instruction() { } /** * Creates a new instruction with the given text * * @param instruction * Instruction text */ public Instruction(final String instruction) { this.instruction = instruction; } /** * Setter for the instruction text * * @param instruction * Instruction text */ public void setInstruction(final String instruction) { this.instruction = instruction; } /** * Converts this instruction into appropriate ContentValues for insertion into the RecipeProvider * * @param recipeId * Mandatory recipeId to be associated with this instruction * @return ContentValues usable by the RecipeProvider */ public ContentValues toContentValues(final long recipeId) { final ContentValues contentValues = new ContentValues(); contentValues.put(RecipeContract.Instructions.COLUMN_NAME_RECIPE_ID, recipeId); contentValues.put(RecipeContract.Instructions.COLUMN_NAME_INSTRUCTION, instruction); return contentValues; } @Override public String toString() { return instruction; } } | http://www.java2s.com/Open-Source/Android_Free_Code/Development/book/com_ianhanniballake_recipebook_modelInstruction_java.htm | CC-MAIN-2022-27 | en | refinedweb |
- Doctrine ORM and Laravel 5
Friday, November 20, 2015 by martijn broeders.
Active Record refers to mapping an object to a database row. Indeed, each row in the database is tied to an object. When you retrieve a row from the database you can update, delete or save using the object itself. That’s how Eloquent and Paris work, and how it’s done in Ruby on Rails.
On the other hand,
Data Mapperis a layer of software which separates the in-memory objects from the database. With Data Mapper the in-memory objects needn’t know that there is even a database present. They need no SQL interface code or knowledge of the database schema. One such solution is Doctrine.
What Is Doctrine?
Doctrine is an ORM which implements the data mapper pattern and allows you to make a clean separation of the application’s business rules from the persistence layer of the database.
Some of the advantages I discovered while using Doctrine with Laravel are:
- Faster and easier to use.
- Entities are just plain PHP objects.
- Doctrine utilizes a “code first” approach, so you can create entities first, and then generate a database for them automatically. The reverse case is also possible, but I do not recommend it.
- Supports annotations, XML and YAML for schema.
- DQL (a replacement for SQL) abstracts your tables away.
- Doctrine events allow you to easily hook onto specific database events and perform certain actions.
- Repositories are more faithful to the repository pattern.
Transactional write-behindmethodology lets Doctrine have less interaction with the Database until the
flush()method is called.
Of course, Doctrine has disadvantages too, but it is up to the programmer to choose the right ORM.
Doctrine DQL
DQL stands for Doctrine Query Language. DQL brings you object query language, which means that instead of a traditional relational query, you have queries in object form.
DQL allows you to write database queries in an object-oriented way, which is helpful when you need to query the database in a way which cannot be achieved (or is very difficult) using the default repository methods.
Sample DQL Query:
SELECT b.id as ItemId, b.title as ItemTitle , b.url as ItemUrl FROM Alireza\Domain\Identity\Entities\Menu u WHERE u.id =:id
Doctrine Filters
Doctrine allows you to limit query results with Filters. For example, you may want to edit only the information of the logged-in user or make sure the current client’s data was returned from the database. A filter is an automatic solution for remembering specific conditions for all your queries.
Doctrine provides SQL level limitations, so there is no need to maintain the clause in multiple repositories of your project. This enhances security and makes your code easier to read.
Let’s look at an example:
/** * @ManyToOne(targetEntity="User") * @JoinColumn(name="user_id", referencedColumnName="id") **/ private $user;
As you can see in the User entity, the result of
JoinColumnis limited to only items with the condition of
WHERE user_id = :user_id.
Setting Up Doctrine 2"
Doctrine needs no database configuration and uses the current Laravel configuration, but if you want to override it you should change the Doctrine config file in
Config/doctrine.php:
'managers' => [ 'default' => [ 'dev' => env('APP_DEBUG'), 'meta' => env('DOCTRINE_METADATA', 'annotations'), 'connection' => env('DB_CONNECTION', 'mysql'), 'namespaces' => [ 'App' ],
That’s all there is to it.
What Is an Entity?
“Entity” refers to an object which has a distinct identity. An entity must have a specific identifier which is unique throughout the entire system, such as a customer or a student. There would be other objects, such as email addresses, which are not entities, but value objects.
Let’s create a Post Entity
App/Entity getId() { return $this->id; } public function getTitle() { return $this->title; } public function setTitle($title) { $this->title = $title; } public function getBody() { return $this->body; } public function setBody($body) { $this->body = $body; } }
The class properties should be the same as the fields in the database table, or you can define them with the
@Colum("name"="myfield")annotation.
What Is a Repository?
The repository allows all your code to use objects without needing to know how the objects are persisted. The repository contains all the knowledge of persistence, including mapping from tables to objects. This provides a more object-oriented view of the persistence layer and makes the mapping code more encapsulated.
Now it’s time to create the Repository in
App/Repository prepareData($data) { return new Post($data); } }
The Doctrine
EntityManagerworks as the access point for the complete management of your entities. Then, create the Controller
App/Http/Controllers/PostController.php:
namespace App\Http\Controllers; use App\Repository\PostRepo as repo; use App\Validation\PostValidator; class PostController extends Controller { private $repo; public function __construct(repo $repo) { $this->repo = $repo; } public function edit($id=NULL) { return View('admin.index')-'); } } }
View and routing are the same as usual.
I prefer to create my own Validator based on Laravel’s Validator class. Here’s the Validator
App\Validation\PostValidator.php:
namespace App\Validation; use Validator; class PostValidator { public static function validate($input) { $rules = [ 'title' => 'Required|Min:4|Max:80|alpha_spaces', 'body' => 'Required', ]; return Validator::make($input, $rules); } }
Conclusion
If you have not previously worked with Doctrine 2, I hope this article has been interesting and informative. Laravel 5 does not use Doctrine, but as you can see, there are some packages which allow us to easily use it with Laravel. I created a simple blog app with Laravel 5 and Doctrine ORM, and I hope this can help you to create your desired app. I welcome your comments.
Leave a comment › Posted in: Daily | https://www.4elements.com/blog/comments/doctrine_orm_and_laravel_5 | CC-MAIN-2018-05 | en | refinedweb |
A Command-Line Java Application
Let's get started with a "Hello World!" command-line Java application:
public class Test { public static void main(String[] args) { System.out.println("Hello DDJ!"); } }
Once compiled on the host computer, copy the .class file to the device with this command (executed from the host):
> scp Test.class root@<IP ADDRESS>:/opt/hello
Next, in the SSH session on the device, execute the application with this command (from the /opt/hello directory):
> java Test
The result is "Hello DDJ!" displayed in the terminal window. Although a simple example, this shows that you can work with the N810 as with just about any other Linux-based computer.
Eclipse SWT GUI Java Applications
Again, because the Jalimo Java installation comes with both a GTK graphics toolkit and a port of the Eclipse SWT libraries, you can easily develop and run GUI-based Java applications for the N810. To get started, download the latest SWT for Eclipse for your host development computer; you can find it at eclipse.org/swt. In my case, I downloaded the Mac OS X version so that I can debug and test my applications locally before deploying to the device.
Next, create a Java project; I called mine SWTTest. With your project selected, click on the Eclipse File menu, choose Import, and then choose Existing Projects into Workspace from within the Import wizard window. Next, browse to the path where the SWT .zip file resides (from the download of SWT), and click the Finish button (see eclipse.org/swt/eclipse.php). In the end, you have access to SWT to develop and run with.
import org.eclipse.swt.widgets.*; import org.eclipse.swt.SWT; import org.eclipse.swt.layout.RowLayout; public class SWTTest { public static void main(String[] args) { Display display = Display.getDefault(); final Shell shell = new Shell(display); shell.setLayout(new RowLayout(SWT.VERTICAL)); Label label = new Label(shell, SWT.CENTER); label.setText("Hello DDJ!"); Button button = new Button(shell, SWT.NONE); button.setText("close"); button.addListener(SWT.Selection, new Listener() { public void handleEvent(Event arg0) { shell.dispose(); } }); shell.open(); while (!shell.isDisposed()) display.readAndDispatch(); } }
To illustrate, I use Listing One, which opens a window that contains the text, "Hello DDJ!," along with a Close button to terminate the application. It's basically a GUI version of the "Hello DDJ!" application we ran previously. Once the .class files are copied to the device, you can execute the application:
> java -cp /usr/share/java/swt-gtk.jar:/usr/share/java/ swt-gtk-3.4.M3.jar:. SWTTest
Eclipse SWT comes with many sample SWT applications, one of which is the File Viewer application that lets you browse folders and files on any computer that can run Java. This application comes in handy on the N810, since it doesn't have a full-featured graphical file browser.
Other Development On the Nokia N810
The Maemo-provided N810 Scratchbox development platform and toolset is based on many commonly available open-source Linux development tools, such as Gnome. The platform includes support for glibc-2.5, GTK+ 2.10, and Qt graphics library and makes cross compilation and application development straightforward. It comes with a GNU cross-compilation tool chain and emulator based on QEMU
Although the official Nokia/Maemo development language for the N810 is C, ScratchBox lets you code in C++, Python, Ruby, C# with Mono, and Java. Applications can be packaged as Debian (.deb) archives, and made available for installation through the Maemo Application Manager tool. Nokia is also working to port Ubuntu Linux to the device, and one community member has ported the KDE desktop to the N810.
Conclusion
Recall I began with a search for an iPhone-like device with a rich UI, multimedia capabilities, and the ability to run Java applications and connect wirelessly to make mobile calls without a carrier. With its wealth of connectivity options, the Linux-based Nokia N810 certainly comes closeand with the recent addition of WiMAX support, it comes even closer. On the other hand, since WiMAX N810 currently only works with Sprint's Xohm network and the nonWiMAX N810 still requires a Bluetooth-enabled cell phone for mobile connectivity when away from a wireless LAN, it's not quite there yet.
But if you're looking for a more open device that runs open-source software and gives you choices in terms of application development and communication options, the Nokia N810 is a perfect choice. As WiMAX gains in adoption, and as the number of free WiFi hotspots grows, Nokia ITOS-based tablets currently offer a reasonable alternative to smart phones with expensive mobile calling plans. | http://www.drdobbs.com/open-source/java-and-the-nokia-n810-internet-tablet/208801979?pgno=3 | CC-MAIN-2018-05 | en | refinedweb |
Freie Universität Berlin
- Hillary Richardson
- 2 years ago
- Views:
Transcription
1 Freie Universität Berlin Fachbereich Informatik und Mathematik AG Technische Informatik Dipl. Inform. Dipl. Kaufm. Tobias Fritsch DOCTORAL DISSERTATION Dissertation zur Erlangung des akademischen Grades eines Doktors der Naturwissenschaften im Fachbereich Mathematik und Informatik der Freien Universität Berlin Next Generation Massive Multiplayer Games in a Mobile Context Eingereicht bei: Prof. Dr.-Ing. Jochen Schiller Prof. Dr. Mark Claypool Dipl. Inform. Dipl. Kaufm. Tobias Fritsch Matr.-Nr Anschrift Angermünder Straße 1a Berlin Tel Ort/Datum Berlin, den
2 Gutachter: Prof. Dr.-Ing. Jochen Schiller Prof. Dr. Ing. Knut Reinert Prof. Dr. Günter Rote Dr. Achim Liers Prüfungsdatum der letzten Prüfung:
3 I Acknowledgements The work in this thesis presents the results of my scientific studies as a PhD student at the Freie Universität Berlin. Research was mainly conducted by the mobile gaming workgroup, which is a project of the Freie Universität Berlin s computer science department. I would like to take this opportunity to thank everyone for supporting me during this time. First of all, I owe my deepest gratitude to Prof. Jochen Schiller, who was the primary adviser of this doctorial dissertation. His immense motivation always encouraged me to continue working unrelentlessly in order to achieve the scheduled tasks. By providing me with tremendous flexibility during my first three years, he further supported my inspiration and therefore significantly helped to complete this work. His knowledge of and insight into technical computer science is remarkable; he always managed to maintain an overview of the large scope of this work. Furthermore, I would like to thank Dr. Hartmut Ritter for acting as my second adviser. His profound knowledge and practical experience helped me understand my task as a PhD student much more clearly. His amazing ideas and motivation substantially modified my work and gave me insights into the scientific importance. I would also like to thank Benjamin Voigt for his inspiration over the last three years. I had the fortitude to have a friend who was consistently honest with me, hence giving me the clearest feedback to point out problematic fields. His support of and insight into the psychologically related fields of my research have been most valuable for me, thus I am very grateful. On par with that, I would also like to thank Peter Harmjanz for his loyal support. His thorough perusal and correction of my drafts ensured long-term high quality. Due to his immense insights into the gaming scene and player-oriented feedback, I was inspired and advised more than just once. Even with tight deadlines, he always found the time to help me with my research, hence he deserves my deepest regards. Finally, I would like to thank my mother for her unique and absolutely irreplaceable support during my education and my ongoing scientific work. Without her skill to coordinate and manage, her ability to encourage and motivate me, her strength and love, I would not be half the man that I am. Therefore, I would especially like to dedicate this work to her.
4 II Abstract (English): Within the last few years, the importance of (multiplayer) computer games has experienced immense growth. On par with that, the size of persistent virtual environments (VEs) has also increased. Today, more than 120 MMOGs (Massive Multiplayer Online Games) ranging from FPS (first person shooter) to classic RPG (role playing game) settings exist. This illustrates the significant influence of the growing number of simultaneously playing users. The way that games are played has also evolved. Not only has the community and variety of gaming grown in numbers; but the way games are understood has changed fundamentally, too. In fact, terms like hardcore (a behaviour regarding the game; describes a far above average interest in the game content and a strong motivation to achieve) and casual (attempts to play the game with below average interest) have become well known in the player scene. Hence, player behaviour is one of the most valuable influencing factors. Furthermore, the importance of mobile games has increased rapidly as well, leaving no doubt that the current game evolution aims for more flexibility towards locations. Thus, new problematic fields in the mobile sector are arising, especially with regard to real-time applications. This dissertation will focus on the current game evolution and pinpoint the most important related approaches. It will subsequently introduce certain techniques to improve aspects of each of the most significant influencing factors: massive multiplayer, mobile gaming and player behaviour. The first research approach aims to understand the underlying player preferences in order to create better software solutions. As a part of this, the effects of virtual fragmentation (difference between real world and virtual world behaviour) and game time distribution will then be evaluated and statistically analyzed. The second approach aims to improve the mobile gaming performance by analyzing limitations in input and display of current mobile devices. By using a software solution, the matching time for players is improved drastically and by integrating mobile support for instant messengers, each user can also communicate with in-game friends who play common Internet games. The third approach introduces a middleware solution to support MMOG games. By designing a message-based structure and creating a generic application, it can be expanded for the upcoming next generation MMOGs.
5 III Abstract (German): In den letzten Jahren gewann die Wichtigkeit von (Multiplayer) Computerspielen zunehmend an Bedeutung. Zusammen damit vergrößerten sich die virtuelle Umgebungen (VEs). Heute existieren mehr als 120 verschiedene MMOGs (Massive Multiplayer Online Games), die von FPS (first person shooter) bis hin zu klassischen RPG (role playing game) Settings reichen. Diese Entwicklung illustriert den signifikanten Einfluss der zunehmenden Anzahl an (gleichzeitig) spielenden Nutzern. Des weiteren hat sich die Art Spiele zu spielen weiter entwickelt. Nicht nur die Anzahl der Spieler und die Vielfalt der Spiele hat zugenommen; vielmehr hat sich die Art Computerspiele zu begreifen fundamental verändert. Tatsächlich sind Termini, wie hardcore und casual in der Spielerszene sehr bekannt geworden. Deshalb ist das Spielerverhalten einer der wertvollsten Einflussfaktoren. Außerdem hat sich die Wichtigkeit von mobilen Spielen rapide entwickelt und lässt keinen Zweifel offen, dass die aktuelle Entwicklung klar auf höhere Flexibilität seitens der physischen Orte setzt. Dem entsprechend entstehen neue Problemfelder im mobilen Kontext, besonders in Verbindung mit zeitkritischen Applikationen. Diese Dissertation fokussiert sich auf die derzeitige Spieleentwicklung und zeigt die wichtigsten verwandten Themenansätze auf. Darauf folgend werden verschiedene Techniken vorgestellt, um Aspekte der wichtigen Einflussfaktoren zu verbessern: Massive Multiplayer, Mobile Gaming und Spielerverhalten. Der erste Ansatz beinhaltet eine Evaluation von Spielerverhalten, um die Erstellung effektiverer Software zu ermöglichen. Besonderer Fokus liegt hierbei auf dem Effekt der vitual fragementation (Unterschied zwischen realem und virtuellem Verhalten) und der Gesamtspielzeit, die beide statistisch analysiert werden. Der zweite Ansatz zielt auf mobile Spiele ab, deren Eingabe- und Darstellungslimitationen evaluiert werden. Mit einer Softwarelösung in Form einer mobilen Lobby entsteht die Möglichkeit die Spielevermittlungszeit drastisch zu senken. Des weiteren ermöglicht die Integration von Instant Messengern für mobile Endgeräte die Kommunikation mit Spielern aus klassischen Internetspielen. Der dritte Ansatz beinhaltet eine Middleware Applikation, um speziell MMOGs zu unterstützen, durch das nachrichtenbasierte Design ermöglicht dies sowohl Skallierbarkeit als auch Integration für künftige MMOGs.
6 IV Table of Contents Page 1. Introduction Problem Statement Scientific Contribution Thesis Overview Background Game Evolution In-Game Communication Technical Realization Mobile Gaming Massive Online Gaming Player Behaviour in Online Games Summary Related Work Definition of the Assessment Parameters Mobile Aware Games Asynchronous Mobile Gaming Near-Field-Areas and Mobile Games Massive Multiplayer Games Using and Detecting AIs in MMOGs P2P Architectures in MMOGs Public Server and FreeMMG Gaming Middleware Middleware as a Service Platform Middleware Example: OpenPING Middleware Patch Scheduling and Middleware Support Player Behaviour Cheating in Computer Games...65
7 3.5.2 Categorization of User Behaviour Game Influence in Real Life Summary Approach I: Understanding Player Behaviour Motivation and Overview Technical Background for the Player Analysis Operationalization Database Architecture Language Support and Views for the Online Survey User Selection Data Cleaning Mechanisms for Online Surveys Regression Analysis as a Statistical Method Hypotheses Questionnaire I: Distribution of Online Player Behaviour Background Hypotheses for Distribution of Online Behaviour Questionnaire II: Virtual Fragmentation Background Hypotheses for Virtual Fragmentation Methodology and Advertisement Sampling Methodology Summary Approach II: Next Generation Mobile Gaming Motivation and Overview Mobile Communication for Games Analysis of the User Group for Mobile Applications The Factor Mobility and its Technical Aspects Problematic Field: Mobile Gaming Mobile Devices and Java Micro Edition Academic Approach: Lobby Tool Problematic Field: Instant Messenger Academic Approach: Generic IM Integration V
8 5.3 Implementation of a Mobile Gaming Communication Approach I: MCChat A Mobile Communication Lobby Approach II: In-Game IM Instant Messengers in MMOGs Summary Approach III: 4MOG Middleware Requirements Overview and Motivation Functional Requirements Nonfunctional Requirements Constraints System Model Design Modularization Functionality Validation Comparison with other Middleware Testbed Summary Experimental Results Statistical Analysis of Player Behaviour Statistical Analysis of Virtual Fragmentation Results of the Mobile Lobby Survey Testbed Results of the 4MOG Middleware Comparison with the Related Work Player Behaviour Mobile Lobby MOG Middleware Conclusion and Future Work Conclusion Player Behaviour Mobile Gaming VI
9 MOG Middleware Future Work Appendix Abbreviations and Glossary Additional Figures References VII
10 List of Figures VIII Figure 2.1. Revenues from the computer gaming industry with regard to platform and user type Figure 2.2. Screenshots of examples from every game-type Figure 2.3. Example of a split screen game...20 Figure 2.4. Illustration of a server-client structure Figure 2.5. A peer-to-peer network with five participating clients Figure 2.6. Example of a hybrid system with a central arbiter...29 Figure 2.7. Illustration of a common MMOG multi-server architecture...30 Figure 2.8. Influence of latency on the game performance at the example of UT...33 Figure 2.9. Influence of latency on the game performance at the example of WC3.34 Figure 3.1. Illustration of the asynchronous game design...41 Figure 3.2. Example picture of a passive RFID tag...45 Figure 3.4. Illustration of different technologies in the P2P MMOG architecture...53 Figure 3.5. Example of a FreeMMG architecture...54 Figure 3.6.Illustration of the MMOG platform for content control...58 Figure 3.7.Design concept of the OpenPING platform Figure 3.8. An Overview about the required MMOG bandwidth...63 Figure 3.9. Figure of a 3D illustration of two virtual players...67 Figure The Venn diagram for player classification...69 Figure 4.1. The solo competition...75 Figure 4.2. The group competition...76 Figure 4.3. The PvP competition...77 Figure 4.4. The PvE competition...78 Figure 4.5. Illustration of the survey database...85 Figure 4.6. Illustration of the sampling process...88
11 Figure 4.7. Computer games divided into sub-groups by game-type...91 Figure 4.8. Illustration of the virtual fragmentation approach Figure 5.1. Current AOL IM version Figure 5.2. Illustration of the current chat situation in MMOGs Figure 5.3. An overview about the complete online survey Figure 5.4. Male and Female opinion on playing mobile phone games Figure 5.5. Model of a consistent common namespace for IM Figure 5.6. Screenshots of the mobile gaming lobby Figure 5.7. Login at central authorization server Figure 5.8. Integration of the AIM into Eve Online Figure 5.9. UML diagram of the IM Chat integration Figure Sequence diagram of the login procedure Figure 6.1. The 4MOG application and its advantages Figure 6.2. Use Case diagram of the 4MOG middleware Figure 6.3. Class diagram of the 4MOG server side Figure 6.4. Class diagram of the 4MOG client side Figure 6.5. UML diagram of the Gamestate class Figure 6.6. UML diagram of the Server and Client class Figure 6.7. UML diagram of the StandardClient class Figure 6.8. UML diagram of the StandardServer class Figure 6.5. Illustration of the testbed Figure 7.1. Age distribution among the different game types Figure 7.2. Game related activities divided among different game types Figure 7.3. Virtual Fragmentation of the attribute conscientiousness Figure 7.4. Box plot of the age distribution in VF Figure 7.6. Illustration of the average penalty level for each group IX
12 Figure 7.7. Diagram of the game field and the AOI area Figure 7.8. Diagram of the average RTT with decreasing AOI values Figure 9.1. Illustration of the server-domain model from GASP Figure 9.2. UML diagram of the 4MMOG middleware network classes Figure 9.3. UML view of the client side of the 4MMOG middleware Figure 9.4. UML view of the server side of the 4MMOG middleware Figure 9.5. Example of the message system in the middleware application Figure 9.7. UML Diagram of the complete message system Figure 9.8. Complete overview about the Client side of the middleware Figure 9.9. Complete overview about the server side of the middleware Figure First solution approach for the IM integration Figure Final solution for the IM integration Figure The component structure of the IM framework Figure Complete class overview of the IMInterface Figure 9.14 Sequence diagram for the connection process Figure 9.15 Methods of the ClientManager in the IM framework Figure 9.16 Methods of the ClientInterface in the IM framework Figure 9.17 Methods of the AimClient in the IM framework Figure 9.18 Methods of the BuddyList in the IM framework Figure 9.19 Methods of the Buddy in the IM framework Figure 9.20 How hardcore are you survey questions Figure 9.21 Virtual Fragmentation survey questions Figure 9.22 Illustration of the Join() function in the mobile lobby Figure 9.23 Illustration of the education level in the VF survey Figure 9.23 Virtual Fragmentation for the factor agreeableness X
13 XI List of Tables Table 1.1. Illustration of the problematic fields from a technical and players perspective....5 Table 2.1. Overview of the different game types...14 Table 2.2. Overview of mobile terms...24 Table 2.3. Overview of the connection types Table 3.1. Overview of mobile gaming network technologies...40 Table 3.2. Assessment of the related attempts...73 Table 4.1. An illustration of competition possibilities...75 Table 4.2. Effects of multiple participations Table 4.3. Overview of the survey participants Table 4.4. Gender distribution in the online surveys Table 5.1. Main questions of the follow-up survey Table 5.2. Relevant problems in mobile game design Table 6.1. Group setup of the testbed Table 7.1. Measurement of positively answered questions Table 7.5. Penalty level system of the 4MOG middleware testbed Table 7.3. Assessment of the related attempts: Table 8.1. Overview of the contribution
14 1 1. Introduction Free advice is worth the price, Robert Half. The gaming market s enormous growth over the last five to ten years reflects the acceptance and importance of multimedia entertainment. One element of this market is that the gaming industry s total revenue already exceeds that of the film industry by far (box sales); and growth is still ongoing. Within this evolution, one can observe that especially interactive multiplayer and mobile applications are growing rapidly. Without a doubt this evolution also significantly increases the number of related research approaches and hence their scientific importance. The research field of gaming contains a wide variety of problematic fields, ranging from graphical performance and efficient network structure design on to social influencing factors like player behaviour. Due to the number of different problems, a single best practice solution cannot be created for all of them. The current gaming multiplayer scene is made up of four main game types: FPS (first person shooter), RTS (real-time strategy), RPG (role playing game) and SG (sport games). Each of them covers its own set of problems and its own set of players. In general, gaming applications are very graphic intensive; a major part of the modern video card design and their visual computing performance relies on the needs of game applications. Due to growth of the Internet, the multiplayer aspect of computer games also contains an important problematic field. Most of the applications are strictly real-time-based and have less to no tolerance towards latency (delay between sender and receiver), jitters (variance in the delay between sender and receiver) and package loss (loss of pieces of data between sender and receiver). Therefore, gaming research correlates highly with real-time video streaming research. To understand the next generation of games, one must look at the current state-of-the-art as well as the user groups needs. Besides obvious aspects arising from computer gaming like efficient network models or cheating protection, there are also social aspects. Several research approaches take a certain player behavior as a given assumption; but ultimately, the users are the ones
15 who determine how a game is played. By taking the users behavior into account, the design of current games can be further improved and already existing games can be customized to fit the individual needs. Therefore, user behavior is one of the most important influencing factors for both game design as well as for conceptual improvement. Another factor is the speed of game applications. The rapid pace in the game environment leaves practically no room for typing conversations during the action. Thus, players tend to use third party applications like voice communication tools in order to coordinate in-game activities better. Hence, gaming research is not only limited to mere game design, but further features like audio and video chat will also be more common in next generation games (for instance several online games already implement voice chat as an optional feature, so users do not need to download external applications). Furthermore, the general gaming trend focuses on MMOGs (Massive Multiplayer Online Games) as the most popular game type. The integration of players into persistent online environments (online worlds that exist 24 hours a day) creates a completely new social structure. Players therefore even spend money in order to play in these persistent online worlds as long as they are rich in content and highly interactive. As a result, MMOGs are becoming the dominating game type, because they offer players the necessary game depth and social interaction. A look at the MMOG market underpins this trend further. In the year 2000, only 15 commercial MMOGs were released, mostly focusing on the RPG sector. In contrast to those numbers, six years later more than 150 MMOGs were launched and at least 50 more were scheduled [MMOR]. By significantly increasing the number of simultaneously playing users, the aspect of scalability and game speed becomes ever more important. Those game types open up a completely new set of problems due to their massive number of players (normal multiplayer sessions now contain two to 20 players, whereas MMOGs have several thousand players), such as hosting the game environment on multi-server architectures or coping with latency at several game events with 200 or more players. To solve the current problems and combine the ideas of massive and mobile gaming, 2
16 it is necessary to understand the current network structure and the effect of latency on the game. Another aspect is the huge size of the game worlds, taking multiple servers to host the complete virtual environment (VE). Thus, techniques for separating the world into different parts are needed. Two main game structures now exist since the emergence of the first MMOGs. The simple implementation approach is the zonebased structure, which basically separates the whole game world into different zones (smaller parts). Those are small enough to host them on a single server. One must differentiate between the in-game view (players perspective) and technical realization. The zone borders are interlinked and from a player s perspective each time he/she reaches a border, a loading screen appears and interrupts the game play. After the loading is completed, the player starts in the next area. From a technical perspective, zone borders are used for handovers. The player leaves server A and is forwarded to server B that hosts the next zone. Furthermore, the loading screens are used to clear the non-persistent information (like graphical animations and models) from the last zone in order to release RAM for the next zone. The other implementation approach is the seamless environment, where zone borders do not exist. For the player, this is like a completely seamless, never-ending world, although the game world is separated. The important connecting areas are hosted on two different servers. From a player s perspective, the gaming environment is seamless, and no loading screens appear. However, from a technical perspective, there are different zones: as soon as the player reaches the border of the zone of server #1, he/she automatically enters a handover area. This section is synchronized between the two adjoined servers. The handover to server #2 does not take place immediately, it occurs after the player has completely crossed the handover area. The disadvantage of this approach is the high programming complexity and the growing traffic in case of events in the border zones. Another one of the most important trends is the growth of handheld devices (mobile gaming devices). Not only are commercial, game-oriented handhelds such as the Nintendo DS or the Sony PSP used; but the significant market penetration of more than 90% in younger peer groups also promotes the mobile phone as a common gaming platform as indicated in [Frit ]. The growing number of releases and 3
17 the relatively strong market demand for mobile devices underscore the mobile gaming sector s potential. Together with the increasing social acceptance of mobile games, one can observe rapid changes in the devices technical equipment. For instance current mobile phones feature color displays, RAM and hard disks in order to run mobile computer applications. As a result of technological change, the gaming industry will further orientate itself towards the next generation of gaming, which is mobile. As an example: at [Mobi] overall game revenue of mobile phone games in the US market shows a 61% increase from 2005 to 2006, and current mobile game revenue amounts to USD 151 million for the fourth quarter of A further increase is expected in the future. With the major trends in computer game design, a) growing player numbers and b) a strict orientation towards a mobile environment, one can observe the wide range of related problem sets. This is further underscored by the growing social acceptance, the major influence of the player behaviour and the rapidly increasing size of the gaming market Problem Statement Due to the high complexity of the gaming sector and the individual requirements for each of the game types, the resulting problematic fields are customized as well. Although the four main game types also feature a good number of similar key characteristics, they only differ in terms of emphasizing the influencing factors. For example, network effects like latency have an impact on each of the different game types, as results from [Frit ], [Clay 2005], [Beig 2004] and [Shel 2003] show. Hence, the user s performance decreases with an increase in latency. Nevertheless, the impact on RTSs and FPSs is higher than in RPGs or SGs. Therefore, the effect of latency is one of the main aspects for FPSs and RTSs. Table 1.1 gives an overview of the problematic fields of each of the four main game types. Network effects. The category of network effects includes latency, jitters and packet loss. Generally, all of the effects have a strong negative influence on the user s performance. Due to an increase in latency or jitter (latency spikes) the reaction time
18 is reduced, making it harder for the player to react to game events. Due to the fast paced design of real-time games, a packet loss of an important in-game action (like shooting) can also have negative consequences (for example, an opponent is not dying). As related studies show, players with diverting network conditions and similar gaming abilities reveal considerable differences in performance. 5 Table 1.1. Illustration of the significant problematic fields of the four main game types Game type FPS RTS (MMO)RPG SG Main problematic fields (technical view) Network effects (latency, jitter, packet loss), in-game communication, cheat protection Network effects (latency, jitter, packet loss), synchronous game engine, cheat protection Social interaction, in-game and out-ofgame behaviour, scalability, network structure and network architecture In-game communication, cheat protection, personalized game content (player behaviour analysis) Players perspective Inadequate game events (opponent is not dying, bullets are not hitting) Units are jumping (incorrect positioning), actions are not performed (latency) Other players behave poorly (social interaction problems), slow game play, frequent loading screens Inaccurate game play (positioning problems), repeating game content Game behaviour (in-game and out-of-game). This section features a wide variety of player interactions, both in-game (inside the virtual world, mostly interaction with the players game character) and out-of-game (real world behaviour outside of the virtual environment). Even though potential cheating behaviour is excluded, considerable player misbehaviour still remains. This can range from DOS attacks on to brute force methods to corrupt an in-game server. One example of this is the attack
19 on blizzard Diablo2 hardcore servers; normal players lose their character permanently after death, whereas the entire server could break down for some players, so a backup must be used to restore the players character. Furthermore, game influence on the players real world behaviour is an important aspect as well. In-game communication. With the growing focus of multiplayer architecture, ingame communication between group members is also becoming more important. The additional bandwidth required of audio or video communication leads to less remaining bandwidth for the game engine and hence to a lower player performance. The result is a trade-off between enhanced communication quality and in-game performance. Cheat protection. Cheating is one of the most serious problems for all of the games. With fiercer in-game competition, especially professional, competitive games from the FPS and RTS section suffer from substantial game cheating. Hence, reducing vulnerability and categorizing different cheating mechanisms is the main aspect of this section. Social interaction. By creating persistent online environments, the social interaction structure between the different players has changed. Thus, aspects like tolerated ingame behaviour, the creation of player groups, large player communities (like guilds or clans) and the value of in-game goods are addressed in this section. Scalability. Due to the growing number of simultaneous players in the MMOG game design, the current TCP and UDP network layers are reaching their limits. Especially due to high network condition requirements it is important to distribute in-game load in between the multiple servers. Also game events and raiding (a large group of cooperating players try to kill a single strong opponent) are addressed as typical scenarios that require a flexible and dynamic in-game scaling. Network architecture. This section covers the usability of different network architectures with regard to individual requirements of each game type. The common architectures are S/C (server client), P2P (peer-to-peer), multi-server and hybrid architectures; each with their individual advantages and disadvantages. This section addresses possibilities to further improve the underlying network structure. 6
20 Technical aspects. Although the users determine how the software is used and whether or not a game is entertaining, several technically related aspects are still required to approach computer gaming from an academic point of view. Due to the continuously growing community, new technical solutions are needed, especially in the problematic fields of massive multi-player gaming and mobile gaming. These aspects cannot only be solved by creating newer technology (however, especially the effect of high performance video cards is a major factor for next generation game design); moreover, efficient solutions for individual problems of scalability (rising user numbers), quality of service (supporting the virtual environment with necessary bandwidth) and hardware expenditure are needed. The technical aspects mentioned will be an important focus of all approaches presented in this thesis Scientific Contribution This thesis contains various attempts to improve the current computer gaming design. Main focus relies on the aspects of mobile computer gaming, massive multiplayer online gaming and on the influence of player behaviour. The computer gaming research field has a wide variety of different aspects, each of the approaches is described individually. MCChat. Especially in a mobile gaming environment, a quick game setup is important due to the low average game time. The current mobile game scene features a large set of problems; one of which is the individual connection mechanism of each mobile multi-player game. Thus physically, neighbours might not be able to find each other; the MCChat lobby offers a dynamic way for a fast game setup and a general place to meet potential opponents. It is based on the J2ME SDK (Java Platform 2, Micro Edition), which aims to create a common standard for the majority of mobile devices. The generic implementation enables other mobile devices like PDAs to use the common lobby in order to find potential opponents. In-game IM integration. Another problem is the variety of different in-game chats for each of the games. With regard to the MMOG gaming scene, a single player is still unable to combine the communication with out-of-game friends and in-game buddies. In-game IM integration, which is introduced in this thesis, has a generic mechanism to embed current instant messengers like ICQ, AIM and MSN into
21 MMOGs, by offering the game all interfaces for basic chat functionalities. If a publisher integrates the in-game IM framework into a MMOG, then a player could combine in-game and real-world buddy lists and reduce the additional third party applications while playing. Furthermore in a mobile content, players who are not running the client could still stay in touch with in-game friends (without needing to run the game client). This is an alternative approach, because it does not downgrade a single game engine to fit the mobile device requirements. It uses already existing technologies (instant messengers and existing in-game chats) to support the pure communication aspect of persistent online environments in a mobile context. The structure of the in-game IM framework is generic to limit it neither towards a single game client nor towards a specific instant messenger. Due to the adoptable interfaces for the game engine, IM support can be easily customized for the MMOG. Only the GUI needs to be integrated by the publisher (all interfaces for basic communication are provided and they only need to be included in the different MMOGs). Furthermore, namespace regulations have also been taken into account to prevent name collusions during the IM in-game integration. This allows the user to keep his/her individual in-game nickname, even while using the instant messenger in an online game. 4MOG middleware. One possible solution for a general problem is to create a software application that acts as a middleware between two layers. In the case of the 4MOG middleware, the approach combines interfaces towards the game engine and the underlying network structure. Generally (for game applications), middleware software can either be completely integrated (internally) or separated from the game engine. The 4MOG middleware acts as an integrated (directly communicating with the game engine) application; it offers the game developer a set of core functions that are required for any MMOG. The reduction of programming effort based on the middleware s functionality provided allows the game developer to focus more on in-game content and on an effective engine design. The middleware s communication architecture is based on a message-oriented system, which reduces communication overhead and also makes it suitable for devices with scarce resources. 8
22 Furthermore, the middleware offers mechanisms to store important player data. This data can be used by the game to keep track of the different players or to store them in a database. Distribution of online player behaviour. Several attempts evaluate the influence of computer gaming on real world behaviour. In order to create reliable data for further player evaluation, this approach analyzes how much leisure time each player invests in gaming (and how seriously players take the computer games). With the gathered data, game-related effects in players behaviour can be identified. Therefore, a statistical analysis with a large data sample helps to evaluate the time each player invests (with regard to the average player, special game types and hardcore users). The relevant hypotheses and explanations can be found in Section 4.3 and their validation in Section 7.1. Technical realization relies on the implementation of a database system. The design should support multiple languages in order to automatically set up the page in the target language. Furthermore, due to intelligent data clean-up strategies, illegal and unrealistic data sets are eliminated, leaving only the valuable answers for further statistical evaluation. Moreover, the general database setup acts as a common platform for further questionnaires and reduces the overall time needed to set up an appropriate online survey for game-related questions. The goal of the survey is to analyze the overall time invested in gaming (compared to available leisure time) as well as to evaluate gaming dedication (how far is a gamer willing to go in order to play more). Furthermore, this survey aims to understand influencing factors for high games times, such as demographic factors, motivation or game type. Virtual fragmentation. This approach focuses on the difference between real-world and in-game behaviour, the difference is called virtual fragmentation. A large questionnaire with demographic and personalized questions based on the psychological five-factor model evaluates the most important personality factors and compares in-game with real-world behaviour. The results further underpin the strong influence of computer gaming on real-world interactions. Hypotheses of the approach can be found in Section 4.4, the brief statistical analysis of the survey is featured in Section
23 The combination of each of the five sub-approaches described improve several parts of the current computer gaming research field and contribute towards more effective and intelligent software designs as well as a deeper understanding about the players motivation. The goal of the survey is to analyze whether or not a significant difference between online gaming behaviour and real-world behaviour exists. This difference will be measured with the help of the five-factor model. If the respective behaviours differ significantly, they will be analyzed in order to identify potential reasons to explain them. As one can see (in Section 4), from a technical point of view both surveys are based on the same database structure and the same algorithmic support for further statistical evaluation. Overall Contribution. The different topics in this thesis cover vital aspects of the current game design. Since the research field of computer games is relatively new, underlying player data is mostly missing. The game producers often do not share confidential data about their customer base and the player behaviour. Therefore, the first step in understanding current trends in the computer gaming field is the analysis of its users. With focus on current online games, both of the surveys aim to evaluate rudimentary questions: the overall game time (distribution of online player behaviour) and the behavioural influence on the real world (virtual fragmentation). After these aspects have been analyzed, this thesis focuses on the two major areas in current computer gaming evolution: (1) the aspect of mobile gaming and (2) the growing number of simultaneous players. Both approaches require an understanding of the computer player. The mobile gaming evaluates the sub-group of casual players in a mobile environment, documents their needs and recommends solutions for the current technology of mobile devices to improve the gaming situation. On the other side, the massive multi-player approach aims to improve the quality of current MMOGs by giving the developer the opportunity to focus on the content instead of the network coding. Both areas share common attributes in their problem-solving approach, since it is the computer player and his/her needs that are the origin of the design. In both cases, the solutions do not mainly aim to improve the current technical implementation, rather 10
24 they focus on a very user desire-driven method to create the most adoptable improvement for the current computer gaming situation Thesis Overview The remainder of this thesis is organized as follows. Chapter 2 introduces the necessary background information about the evolution in computer games. Moreover, the focus relies on the three main aspects of mobile gaming, massive multi-player online gaming and player behaviour as important influencing factors for next generation software design. Within the sub-sections, the most important mechanisms are explained in detail to provide an overview of the current scientific research field of computer gaming. Chapter 3 presents the related attempts and therefore focuses on four categories: mobile gaming, massive multi-player gaming, middleware approaches and player behaviour analysis. The respective advantages and disadvantages of the most important related work of each section are evaluated and summarized afterwards. Chapter 4 introduces the first approach understanding player behaviour. Hence it gives an overview of the motivation and the details of the two sub-sections distribution of online player behaviour and virtual fragmentation. Both aim to understand the influence of computer games and their frequent usage. Chapter 5 contains the second research approach: Next generation mobile gaming. This section focuses on the problematic field of mobile environments and possible game design under these circumstances. The two sub-sections MCChat and IM- Integration are further described in detail; both aim to improve the mobile gaming situation due to a fast matching time and increased communication. Chapter 6 features the third approach: 4MOG middleware. The section also therefore focuses on the respective advantages and disadvantages of middleware applications as well as the explicit design of the 4MOG architecture. Moreover, an underlying testbed is described in order to evaluate the middleware application s scalability. Chapter 7 summarizes the contributions of all three approaches, and then compares the results with related work. Furthermore, statistical results of the testbed and the
25 user questionnaires are analyzed in-depth statistically. Moreover, a final chart illustrates the new approaches in contrast to the related work to pinpoint the overall contributions. Chapter 8 then summarizes and concludes the contribution of this thesis and provides a critical analysis of current scientific limitations in game research. Additionally, it includes an outlook on further work. Chapter 9 contains an appendix with the list of the most important abbreviations and further minor statistical results. Chapter 10 then features a complete reference list. 12
26 13 2. Background The ancestor of every action is a thought, Ralph Waldo Emerson. The research approaches and the most important mechanisms for computer gaming are described in this chapter. It contains an overview of the current game evolution, especially in the last five years and also features statistical numbers in order to underscore the growing scientific importance of this research field. Furthermore, three of the main aspects for the next generation game design are introduced: mobile gaming, massive multi-player online gaming and player behaviour. Each of them contains the major related design techniques that are used for the individual problematic fields. 2.1 Game Evolution Computer games can be categorized into genres by different factors. Hence, a distinct allocation with explicit attributes is difficult. Because of the vast variety of new ideas and the publishers motivation to contact a large number of potential customers, many games tend to fall into more than one of the genres at the same time. The aspect of constantly evolving computer techniques is another important factor for the difficult classification of computer games. That is because due to new technologies, new genres can be created; the most well-known example of such an evolution is the MMOG sector, which relies on the technological evolution of the last ten years. In the related literature several different classification strategies are introduced [Myer 1990], [Wiec 2002]. Table 2.1 gives an overview of the most common categorization of games with a few of their individual traits. Nevertheless, the list of traits is not complete and it will change over time due to new technological and software design modifications.
27 14 Table 2.1. Overview of the different game types Game genre Individual traits Examples FPS Highest graphical performance Halo, Counter-strike RTS AI design, high complexity Warcraft, Command & Conquer SG Realistic game engine FIFA, Pro Evolution Soccer RPG In-depth content, interaction WoW, Everquest Puzzle/Logic Simple & easy game design Tetris, Punisher Edutainment Strict content orientation Learning by numbers Miscellaneous High individuality Bad Milk, Black & White From a business science perspective, the market for computer and video games has experienced tremendous growth over the last ten years, with constantly increasing revenues. Today, the area of video games is one of the leading market segments in the electronic media industry, already exceeding the revenues of box sales from the video sector. According to [DFC], current growth of revenue in the computer gaming industry will even increase: By 2006 we forecast revenue growing to $5.2 billion with continued steady growth so that worldwide online game revenue reaches $9.8 billion by By 2009, we forecast that Asia will still be the largest market, but Europe with forecasted 2009 online game revenue of $2.2 billion will be the fastest growing. (DFC Intelligent Articles, 2007). Figure 2.1 illustrates the expected income broken down by user type and platform. Both factors are important because they strongly influence the way the games are played. As one can see, the gaming market will be dominated by personal computers and consoles.
28 15 Figure 2.1. Distribution of the expected revenue in the computer gaming industry in 2009, broken down by platform and user type Not only do these growing rates reflect the significant improvement in game design, but they also show a change in the social acceptance of computer games. Gaming is no longer only designed for a marginal group of hardcore players (they are expected to only make up 27% of the market share in 2009); it is becoming interesting for a much larger audience. A very important aspect in the interaction between players is the possibility to play against human opponents. The very first computer games such as Pong already provided PvP aspects. Due to the increasing performance in computer networks, these multi-player possibilities have been improved further. Figure 2.2 illustrates multi-player settings for each of the four most important game types: RTS, FPS, RPG and SG. The very first network multi-player sessions were connected by using direct wired connections like null modem cables. During the evolution in network design, LANs overtook multi-player connection aspect, and small groups of players, usually 4-12, played together in networks.
29 16 Figure 2.2. Screenshots of examples from every game type: the screenshot on the upper left shows World of Warcraft (RPG), and the upper right shows Counter-Strike (FPS), bottom left shows Command & Conquer 3 (RTS) and bottom right shows Fifa 2006 (SG) [Gams] Due to the immense growth of the Internet combined with the increasing performance of broadband and cable connections, the player audience increased, too. This trend can be observed by the maximum number of players supported in parallel in the game design. During the years from 1995 to 2000, most of the games featured multi-player support of up to 12 or 16 players. After the successful release of the first MMOGs in 1998 (refer to [Ever] and [Ulti]), the maximum number supported for non-massive multi-player games grew continuously. Up-to-date servers with more than 40 or 50 simultaneously playing users are state-of-the-art. On par with the enormous growth in numbers, techniques to reduce bandwidth requirements increased as well. One of the main aspects in real-time games is the frequent updating of the current in-game positioning. Hence, the technique of Path- Prediction has been implemented in most of the current games [Li 2006]. The
30 individual movement is therefore predicted and pre-calculated in order to reduce the data overhead. Another differentiation for online games is the categorization by the number of simultaneously playing users in a single game session. The number of players mainly depends on the game design and on the game genre; not every setting allows a huge number of participants. Therefore, MMOGs today describe the group of games with a very large number of simultaneous users, usually at least Nevertheless, the resulting number of players can surpass more than 20,000 users during peak times. The group of massive multi-player games is not completely selective; opinions differ regarding the first games in this section. By decreasing the term of massive, in a broader sense Neverwinter Nights [Neve] has been one of the first MMOGs in the year The initial size of the game session was limited to 50 simultaneous players. The first persistent online worlds with massive multi-player support were released in 1998 with Ultima Online [Ulti] and Everquest [Ever], the player numbers for each shard were initially set to a maximum of 2,500 players. In the current generation of games, the new term of UMMORPGs was introduced by Eve Online with a simultaneous player record of 30,538 users on September 4, 2006 [EveO]. The four most important game types (from Figure 2.2) will be used to evaluate the approaches of this thesis, thus each of them is explained in detail (for a description of the game-related terms refer to the glossary): First Person Shooter (FPS). The FPS game section features most of the current games. In most cases, the player can explore instanced areas by using a variety of weapons to compete with opponents. The perspective focuses on the first person, most body parts of the own character are therefore not visible. Due to the competitive nature and the fast-paced game play, this game type is very popular; typical game sessions are minutes. Both individual competitions against a single opponent as well as teamwork in a small group are features of current FPS games. Real-Time Strategy (RTS). This section contains games where the player takes control over a civilization or a large number of military forces. By commanding build structures as well as a large number of units at the same time, the player tries to eliminate his/her opponent. Tactical knowledge as well as fast computer interaction 17
31 are needed in order to be victorious. Due to the high competitive factor, these games are also very popular within the player community. Role Playing Game (RPG). By focusing on a single character or a small group of personalized characters the player obtains the role of a (group of) hero(s). Usually each player only controls a single character in order to develop the characters unique abilities and grow stronger over time. The game content has a strong focus on exploring a persistent online environment and a long-time relationship between the player and his/her character. In most RPGs, competition focuses on PvE (player versus environment), although several next generation MMOGs already include different PvP (player versus player) aspects. Sport Games (SG). The section of sport games features various types of real-world sports. The most popular games feature soccer and basketball scenarios, where the player takes over the role of a complete team. By competing with other teams, each player individually tries to achieve as many cup wins as possible. One important aspect is the PvP interaction over the last few years. The game design of current SGs focuses on creating a realistic game engine in order to support a fair environment. The number of players, however, are strictly limited, usually only two to four players compete simultaneously In-Game Communication In-game communication is now an important research field due to the growing importance of competitive games. Communication among the players is also an important aspect for the management of online game sessions as well as strategies. Hence, a wide variety of communication media is already provided by most online games today. These features are generally textual communication methods in different separated in-game channels (one for trading, clan [a union of players with the same goal], guild [a long-term, large scaling collaboration of players], group [a temporary in-game collaboration of fellow players], friends, etc.). In each of these channels, the players can communicate and, depending on the game type, even send XML links to show their equipment to others. Most of the persistent online games also offer the opportunity to send personal ingame messages to other players. By doing so, the player can chose exactly one single
32 recipient for a private conversation. Friends can usually also be stored in buddy lists to check their online status and to communicate directly with each of them. The chatlogs are nevertheless not generally stored in-game, although several MMOGs offer the opportunity to create local logs of each conversation. One of the most important disadvantages of text conversation is the reduced awareness during the process of typing. Quite often, players cannot type and play at the same time (this especially occurs during fast-paced games like FPS, RTS, etc.). Possible solutions for this problem are communication commands to improve the speed of typing. A player can use shortcuts to trigger short, pre-selected messages for all teammates (like enemy spotted, etc.); FPS games often use this technique. By making further use of the audio technology, current player teams are frequently also based on voice communication tools from third parties. These communication solutions even enhance flexibility due to a wider variance of voice commands, although a microphone and more bandwidth are required in order to run the game and the communication tool simultaneously. Therefore, current third party applications like TeamSpeak provide optimized communication methods with low processor load and different voice encoding strategies for constant data transfer rates. With regard to strict input limitations like game consoles or mobile devices, one should keep in mind that voice communication is even more important Technical Realization Over the years, technical realization of multi-player computer gaming has changed dramatically. One of the main influencing factors is undoubtedly the evolution in network technologies. Hence, the most important techniques are described in detail:
33 20 Figure 2.3. Example of a split screen game (Off-Road Arena) from [Gams] Split Screen. Due to the limited possibilities for a multi-player mode, the first games used a single screen for all players. Therefore, two to four players could interact with each other without using an underlying network. This technique is still frequently used in the console sector, where the TV is the only output device available. Whenever the game world cannot limit the movement of each player in order to ensure that no one leaves the screen, it is necessary to split the perspective up into two individual views. Figure 2.3 illustrates an example of a current split screen design. Single Screen. Just like the split screen, a single screen only uses a single output device for multiple players, although the game engine needs to ensure that none of the players can leave the screen. Common examples of a single screen technique are round-based games, where both players compete asynchronously. Network multiplayer solutions. However, both approaches rely on a software solution geared towards space limitation with a single output device. By connecting different output devices and synchronizing the game environments of each player, one can use additional hardware resources to massively increase the maximum number of potential players. The general idea behind a multiplayer network includes the usage of each user s hardware in order to create a distinct perspective. By using different techniques to
34 exchange important in-game data, consistency of the game worlds is ensured. The result is a common game status that allows each player to interact and ensure a logical concept behind the game. However, information exchange between the users can be based on different network strategies. Historically, the network technology is based on wired cable connections that used the COM port in order to exchange in-game data. Even in mobile environments, the devices are connected through a direct link if the users are playing a multiplayer game. As soon as more players need to be connected, the Local Area Network (LAN) with wired connections replaces the direct links. Basically, the most distributed technology for the setup of LANs (Ethernet) is developed in different versions (10 Mbit/s, 100 Mbit/s and 1Gbit/s). Moreover, different users can also be connected that have distinct standards with a router that automatically calculates the maximum possible bandwidth between two clients. One of the major disadvantages, especially by using bus topologies, is the high probability of a network failure. As soon as the connection of a single client is interrupted, the whole network collapses. Thus with additional hardware (Hubs), most of the LAN networks are configured as a star topology to significantly increase the failure tolerance. The next step in the network evolution is the usage of wireless connections, which enables players to interact in mobile environments without the usage of cables. The data rate varies between 11 Mbit/s and 54 Mbit/s; also two different network structures are supported: the fixed infrastructure and the ad-hoc modus. Although WLANs offer tremendous flexibility, the aspects of security and quality of service are the main aspects. Due to the obstacles, packages can be lost which is why especially connection sensitive game types like FPSs or RTSs are seldom based on a mobile network. Another technology for wireless connection is Bluetooth, which also offers the possibility for wireless data transfer. The maximum data rates of Bluetooth 2.0 (with enhanced data rate) is 2.1 Mbit/s; however, the lower bandwidth is not necessarily a problem for game applications. Bluetooth offers a lower average latency and if no obstacles or other devices interrupt the usage, then the range is also large enough to support most of the mobile games. The usage of a certain technology 21
35 depends strongly on the game requirements and the bandwidth as well as on the maximum tolerated latency. Nevertheless, LANs also have a limited number of players; depending on the structure and the hardware, 16 to 200 players are supported simultaneously. One of the main problems is the sharing of common resources, because as soon as two clients attempt to use the same cable, all packages sent clash. Although technologies like CSMA/CD already reduce the overall number of collisions, the resulting package loss significantly increases with the number of participating clients and the frequency of data transfers; hence scalability is strictly limited. In the last ten years, the trend towards the Internet has significantly changed maximum player capacities. Due to the high bandwidth and the increasing number of Internet households, persistent online environments can be created. Therefore, numbers of more than 10,000 players in the MMOG sector are becoming increasingly common Mobile Gaming The term mobile gaming includes a wide variety of technologies which allow communication beyond the traditional limitation of fixed network structures. Although the term mobile does not only refer to the network structure, it can also refer to the mobility of the players themselves. Hence, mobility of the communication is the opposite of the classical fixed networks, because it allows the user to take the input devices wherever he/she wants. Traditional communication techniques on the other hand require a more specific location. With the increasing importance of portable communication technology such as mobile phones or PDAs, these devices achieve a high market penetration. Nevertheless, the equipment is also capable of running entertainment software like mobile games. Both [Clay 2005] and [Taru 2006] describe the influence of mobile devices on gaming and compare the next generation professional handhelds like Nintendo DS and Sony PSP with the current mobile phones. The other main aspect is the mobility of the communication participants; their equipment does not necessarily need to be mobile as well. Such mobility can be
36 achieved by a special service (personalized terminal design), which is accessible from various locations. Moreover, the service itself can have a fixed position in a network (for example on a fixed server with a HTML front-end), but only single users can access this service by using pre-defined access points (limitation by using a firewall with fixed IP addresses that are allowed access). Each of these points acts as a mobile terminal and offers the user his/her personalized features after logging in. Furthermore, both aspects can be combined by establishing a service that can also be accessed by mobile equipment. One of the most precise implementations of mobility can be found in the mobile telephone network. By equipping the user with radio access technologies and supporting an individual tracking, each mobile phone user has considerable flexibility. Technologies like GPS allow accurate tracking of the user, which can also be used for entertainment applications, so-called location-aware games. In these games a user interacts in the real world and as soon as another player with a mobile phone is close to his/her current position, they can virtually fight against each other. One example of this is a mobile mercenary (soldiers that can fight against each other) scenario, which is shown in [Unde]. Newer mobile networks use IP-based structures to further improve the routing of communication data. In a mobile environment, communication methods are limited as well. For a majority of the mobile games, communication is achieved by using real-time audio. Besides the obvious advantage of audio communication (for example with mobile phones), text-based messages can be delivered and instant chats can be created. The most significant problem is input limitation, even with fast typing it is not possible to react quickly enough. Especially with regard to the FPSs and RTSs, these circumstances lead to a significant in-game disadvantage. However, additional game-related technical issues occur. With regard to scalability, one should keep in mind that classic communication integrates two participants. With an increasing number of potential players and high requirements of the game application concerning latency, jitter and packet loss, the standard GSM protocol has reached its performance limit. Furthermore, one should also take into account that demand for a high QoS (quality of service) for mobile real-time game applications is also significantly higher compared to the standard mobile phone communication. A disconnected player 23
37 cannot simply rejoin a running game (this holds true as long as no main server for login and player management exists); hence a longer period with low to no signal can corrupt a whole multiplayer game session. The transfer mode systems for mobile games mainly use either GSM or UMTS for mobile phones and WLAN for the next generation handhelds and PDAs. Both GSM and UMTS offer high accessibility in most European locations, although the main downside is the high latency and package loss [Heis]. Currently, latency in GSM networks is around ms, which is (depending on the game type) very high. One should keep in mind that an average latency of 100ms already has a strong influence on FPS and RTS games. On the other hand, WLAN provides a more stable connection type (lower average latency, lower package loss), but the transfer range is strictly limited. As indicated above, Bluetooth has a lower bandwidth compared to LAN and the range is also limited. However the latency is better, especially for latency sensitive gaming applications that can be the most important factor for a technology decision. Currently, the trend reveals that the pure gaming handhelds (Nintendo DS [Nint] and Sony PSP [Sony]) both use WLAN as their communication method. The multiplayer game design of their applications seldom considers user reaction as an important aspect. As a result for the current handhelds, for their design decision, the relative higher latency of the WLAN technology is compensated by the higher bandwidth and range. The mobile game market is growing rapidly, although it is still limited due to the mobile devices. Nevertheless, the game design for PDAs and mobile phone games has reached an entirely new level over the last five years. Current trends clearly indicate that the most well-known games feature clones of already successful PC (personal computer) and console versions as shown in [Harm 2004]. In order to summarize the most important aspects of the current mobile gaming evolution, Table 2.2 gives an overview of the major terms for mobile gaming. It includes a short definition of the technical protocols, the aspect of user mobility as well as the common mobile devices that are used for game design. 24 Table 2.2. Overview of the most important mobile terms
38 Mobile term Description Individual traits (game-related) 25 GMS/ UTMS WLAN/ Bluetooth User mobility Mobile phone PDA Nintendo DS/ Sony PSP WAN (World Area Network) mobile protocols for long range data communication LAN (Local Area Network) mobile protocols for short range data communication Location independent flexibility of the end-user; achieved due to terminals or handheld devices Common mobile phones can act as a game device Personal digital assistant, also capable of running current mobile games Current purely game-oriented mobile handheld devices High frequent data communication, cellular structure, game instability Limited range, higher bandwidth, access point structure, problem: Obstacles Individual user behaviour, limited amount of time, quality of service important High market penetration, scarce resources, limited input possibilities, no common standard Independent operation system, large displays, lack of video card support, touch-screen High graphical performance, incompatible with other games, individual input devices 2.3 Massive Online Gaming Online games that are played over the Internet also have their individual set of problems; mainly network factors like latency, jitter and package loss affect the ingame activities. Besides the influence of geographical conditions for the routing, a large overhead occurs by administrating multiple thousands of players in a MMOG. Therefore, each of the game types has its preferences for the network structure, the most common network designs are described in detail. Client/Server structure (C/S). The most frequently used network structure for online games (especially for MMOGs) is the pure C/S system. A single (group) of high performance servers awaits contact with potential game actors (clients). Hence
39 the server offers a service that can be used by each client. In fact, each in-game action, like movement or interaction with the game world, is sent to the server, which acts like a centralized judge. After accepting an action, the server announces the change for all clients affecteds, so they can up date their local game world and ensure its consistency. Figure 2.4 illustrates a basic S/C model with a single server and four connected clients. 26 communication communication communication Figure 2.4. Illustration of a server-client structure In most cases the publisher offers the player community at least one online server to login. The complete in-game environment is kept on the server; every interaction is verified before it affects the game world. Thus, every action by each of the players is checked at least once by the server. With any doubt, the main resulting disadvantage is the bottleneck position of the central server in this architecture. An increasing number of clients leads to an over-proportional increase in the resulting events, therefore the maximum number of players on a single server (shard) in MMOGs is capped to prevent the reaching of a critical number. The scalability of the S/C structure is rather low due to the more than proportional increase in verifications required with regard to a growing number of simultaneous players. Distributed events as shown in [Yama 2005] or encoded message systems [Endo 2006] help to reduce the overall number of verifications, although the general bottleneck problem is still not resolved.
40 Another downside is the high dependence on the server. As soon as the server crashes, the game world with all non-persistent data is lost. Therefore, backup strategies are needed to ensure roll-backs in case of emergencies. On the other hand, these roll-backs indicate a major advantage of the S/C structure. Due to the centralized architecture, consistency of the in-game world can be ensured with comparably low effort, which in turn also reduces potential cheating opportunities. Peer-to-Peer structure (P2P). Besides the centralized version, the network can also be organized as a distributed system. The P2P system only contains clients with equal rights. Every participant is allowed to offer and use services for and from other clients. With regard to P2P gaming structures, each of the participating clients must calculate a consistent local version of the game world. As a result, either the entire or at least a part of the common game world must be hosted by the client. Figure 2.5 illustrates a P2P network model with five participating clients. 27 Figure 2.5. A peer-to-peer network with five participating clients, the arrows represent network communication between the clients Updated messages for in-game events are sent to all participating clients; however, each of them is responsible for updating the game world correctly. Individual computation of each client in a P2P system with a comparison of results afterwards reduces inconsistencies compared to a typical P2P system. Two disadvantages still exist: first, the overhead increases with the number of comparisons (which is
41 especially negative for latency sensitive games) and second, even after results have been compared, loopholes still exist for cheating (for example a group of players that cheats together and compares their modified results with each other). This architecture was first introduced in [Gaut 1998] as a scalable P2P game engine that contains several cheat protection mechanisms. The main advantage of a scalable P2P system is the non-existence of any bottlenecks. Communication between the clients therefore enables the reduction of an indirect server communication s average latency time. Another advantage is the minimized amount of bandwidth from the publisher, which reduces overall hosting costs. Furthermore, a possible breakdown of the server cannot occur, although depending on the implementation of the P2P network, as soon as multiple clients are disconnected or when they go offline, the resulting game world might collapse, too. In that case, the required backup would not be as accurate as in the C/S model, persistent data could even get lost, which demotes the P2P structure for persistent online environments of MMOGs. Hybrid network structures. The advantages of the P2P and S/C structure are combined in the hybrid network system. It features the cost efficient P2P bandwidth distribution as well as the lower average latency, combined with the S/C advantages of a high publisher control and a centralized organization. The resulting differences in network performance of the three architectures are evaluated in [Pell 2003]. Figure 2.6 shows a hybrid network structure with a central arbiter node. 28 Central Arbiter communication Client 1 Client 5 Client 4 Client 2 Client 3
42 Figure 2.6. Example of a hybrid system with a central arbiter, the arrows represent network communication between the clients 29 A hybrid system with a central arbiter works similarly to a P2P structure, because messages are exchanged between the clients and are also sent to the central arbiter. This node acts as a listener of the network traffic and simulates the game world with the events received. The peers still calculate the game world locally, and as soon as inconsistencies with the central arbiter occur, all other clients are informed in order to synchronize the distinct game worlds. The resulting network structure is less vulnerable against cheating and shows a better scalability than the pure S/C implementation. Nevertheless, complex implementation and the slight loss of control from the publisher are the main downsides that prohibit a usage for commercial games today. On the other hand, the combination of different servers is frequently used. Especially publishers with monthly fees require a separate login system as well as a secure verification database. Furthermore, another high performance database is required for all in-game objects and characters to store the important persistent player data. Moreover, individual zone and shard servers are needed to distribute the load in the game world. An illustration of a simple MMOG network structure is shown in Figure 2.7.
43 Figure 2.7. Illustration of a common MMOG multi-server architecture [Frit ], the arrows represent network traffic between the different stations 30 The typical MMOG multi-server architecture, as shown in Figure 2.7, includes several login servers. These are directly linked to the authentication database in order to receive valid information as to whether or not a player possesses an active account or is already logged in. If the player is already logged in (character exists in the persistent online world), then either the current login session is terminated or the attempt to login will be aborted. This strict system is required to allow multiple users to play with a single account at the same time; especially due to Internet-sharing the IP addresses can be similar. Furthermore, the online world must remain consistent and it must be possible to ensure that the same character can exist online multiple times. The world server hosts the consistent online environment and is responsible for every zone server (part of the online world) as well as the database for items (potential treasure that a player can gather), drop-tables (list of loot that every NPC possesses) and, of course, player characters (including all items and skills that a player possesses). As one can see, this position creates a typical bottleneck situation. As soon as the world server receives too many packets, it will have to either set priorities or try to solve the in-game actions with a best practice approach (tries to handle as much as possible). This can lead to inconsistency or the lack of important persistent data change (like gaining a level). Hence, it is a technical trade-off between the options of restricting the maximum number of possible players per world server (sharding) or creating a multi-server system for the world servers (ultra massive multiplayer online roleplaying game). Both approaches have their advantages and disadvantages: by reducing the maximum number of potential players, the problem of scalability is solved by not dealing with a number greater than n players. On the other hand, implementation complexity is drastically reduced because the integration of a multiserver system requires additional support for database access (interlocking and deadlock problematic) as well as a consistent game world management (handovers between each of the world servers).
44 31 Table 2.3. Overview of the different connection types Network type Description Individual traits (game-related) P2P S/C Hybrid Multi Server A pure client hosted network topology, information is stored locally with each user Server-Client: The server acts as a controlling entity, no direct data communication between clients Mixed structure between P2P and S/C, the arbiter acts as a controlling instance Typical MMOG server structure, additional controlling unit for authentification Low cost, high scalability, problem consistent game world, persistent data needs to be distributed Bottleneck position, low scalability, central controlling mechanism, single data channel, typical network type Problem: Important data needs to be controlled by arbiter, difficult implementation, positive aspects of both structures Complex system, bottleneck position of the world server, medium scalability, database connection In order to summarize the most important aspects of the current massive multiplayer gaming evolution, Table 2.3 gives an overview of the different network types. It includes a short description as well as an analysis of the game-related aspects. 2.4 Player Behaviour in Online Games The aspect of player behaviour and its influence in computer gaming has been attracting ever more interest over the last five years. Nevertheless, the topic is not only limited to the adoption of in-game behaviour, one of the main aspects also includes the player s performance under problematic conditions such as high latency, jitter and package loss. Thus, each of the most important network effects is described in detail.
45 Latency. Especially in the MMOG sector, where S/C network structures are most common, the round-trip time of a message is an important factor for the clients. Generally, a high round-trip time (which equals a high latency) has a strong negative influence on the player s behaviour, therefore massively reducing the in-game performance compared to other players. A bad connection to a server can have multiple reasons, ranging from a high physical distance, a high server load (bottleneck position) on to a slow Internet connection (the effect is called last mile ). In order to prevent large physical distances between the clients and the server, next generation MMOGs often offer different access points, i.e. one for Europe, one for Asia and one for the United States. The problem of slow Internet connections is also diminishing; more and more households in Germany have Internet access and especially households with a high number of people (3+) show a high availability of Internet access [Stat]. One possible result of the Internet sharing is also the increase in bandwidth, which further reduces the users limitation from a gaming perspective (because of the higher available bandwidth). One of the remaining problems is the error correction protocol in most high bandwidth connections, which increases the overall latency by 60ms to 80ms, hence several gaming flat-rates with low bandwidth and no correction protocols are offered. The tolerated latency differs for each game type, while FPSs and RTSs require a maximum latency of 150ms, SGs and RPGs can run fluently with a round-trip time of up to 500ms. As soon as the latency increases, one can observe significantly lower in-game performance. In order to illustrate the differences, Figure 2.8 shows the influence of latency on player performance in a FPS (Quake 3); with higher latency, the average kills/minute decrease. The slope of the curve is continuous, although one should keep in mind that a reduction of 40 kills/death to 30 kills/death will further increase with a higher latency (see Figure 2.8). Figure 2.8 illustrates the example of induced latency in user performance for the FPS Unreal Tournament. As one can clearly see, the kills per match decrease significantly with a higher induced latency. The deaths per match were also increasing. Both effects together drastically lower the player s performance due to the faster reaction time in-game. The current game situation received is one of the most important data 32
46 sources for player interaction. Assuming a more or less normally distributed human reaction time of 100ms to 200ms, an additional latency of 200ms leads to an unequal game situation. Not only is the pure latency responsible for the significantly lower performance, but the main factor in PvP situations is also the relative difference between latencies of the competing users. If every user receives additional latency, then the relative reaction is only affected partially; whereas a total difference of more than 200ms will drastically effect the in-game situation. 33 Figure 2.8. Influence of latency on the game performance exemplified by the Unreal Tournament (FPS) [Beig 2004] A similar example can be seen in Figure 2.9, an observation of a RTS. In this case, the testbed setup included different tasks for the participants. One of the tasks was the exploration of an area with different induced latencies. As one can see in Figure 2.9, the overall time needed by the players to explore their game environment proportionally increased with the induced latency. Generally, the reaction of the game avatar was delayed due to the higher RTT (round-trip time) for the TCP packages from the client to the server. As the related paper [Shel 2004] describes in
47 detail, these effects were also noticeable during other parts of the game like building and especially during the human interaction (PvP). 34 Figure 2.9. Influence of latency on the game performance exemplified by Warcraft III (RTS) [Shel 2004] Packet loss. If a packet is lost while the game is running, the game world can become inconsistent. For example, a player who is shooting at an opponent might notice that his bullet never reaches the target because the information is lost in the network. The game server can reduce this effect by predicting possibilities for upcoming behaviour of the participating players. With regard to movement, the current movement is pre-calculated by using the current movement speed and direction and only in case of differences between the real movement and the predicted movement will the difference be corrected (this mechanism is called Dead Reckoning). However, important packages like shooting or interacting with an important in-game object cannot be predicted, thus making a loss of these important actions very harmful for a consistent game environment. Jitter. The aspect of jitters in an online game is another negative network effect. It describes the variance of the latency, the higher a potential maximum of latency is, the more influence on game performance can be observed. The so-called lag spikes often occur during action intensive times, where several participants are interacting with each other simultaneously.
48 Typical game interactions like anticipating the current movement of an opponent and pre-aiming to a specific location are also corrupted by a high variance in latency. The game becomes more random, hence the treatment of each player relies more on the network effects. Jitters can occur for several reasons; the main cause is the usage of different routing paths or a distinct load of the Internet access (often caused by file sharing). A strong jitter effect has similar results as those of a package loss, important information is received too late and therefore the game world becomes inconsistent Summary This sections contained a detailed description of game evolution in computer gaming. Therefore the main game types, their individual requirements and the relevance of computer entertainment have been outlined. The three main computer gaming aspects of this thesis: mobile gaming, massive online gaming and player behaviour have also been explained in detail in order to give an overview of the most frequently used techniques. This includes a summary of the most important network models, display techniques, mobile gaming effects as well as network effects.
49 36 3. Related Work I often quote myself. It adds spice to my conversation, George Bernard Shaw. The rapidly evolving field of computer gaming research has attracted a large number of different research approaches. This chapter will give an overview of the most important related work with a focus on three main aspects: mobile gaming, massive multiplayer gaming and player behaviour influence. The usability of middleware applications will then be presented and concrete examples of related work will subsequently be summarized. Each of the approaches introduced will focus on one of the four central aspects in computer gaming: mobile gaming, massive multiplayer gaming and middleware design as well as player behaviour analysis. All of them are described in detail in their section and are analyzed afterwards with regard to the assessment parameters of this dissertation: scalability, mobility, reusability, quality of service, user behaviour and hardware expenditure. 3.1 Definition of the Assessment Parameters The highly varying characteristics of the related work approaches make it difficult to compare them directly against each other or find a one-best-way solution. Hence Table 3.2 at the end of the chapter introduces an overview to assess the different approaches with regard to the parameters: scalability, mobility, reusability, quality of service, user behaviour and hardware expenditure. The general parameters are defined as follows: Scalability. This factor measures how well a given approach performs with an increasing number of players and/or network size. The growing importance of MMOGs and the large number of simultaneously acting users promote scalability as an important factor. Of particular interest is how stable and effective the mechanisms identified perform with a critical mass and whether or not the overhead generated is
50 what makes the game unplayable. Each attempt can range from (++/ Excellent) to (--/ Very poor). Mobility. This measurement includes the scientific contribution to mobile environments. Besides the growing numbers of simultaneous players, mobility is one of the main factors in next generation game design. Hence this assessment parameter describes the potential of each related work attempt to use a mobile environment for gaming. By integrating mobile protocols such as GPRS/UTMS or using wearable gaming mechanisms, each attempt can range from (++/ Excellent) to (--/ Very poor). Reusability. The reusability of a given attempt describes how well it can be adapted to the next generation of games. Especially different game genres often require a special solution; flexible ideas can be transferred to a wider selection of target applications. Thus the reusability can vary from (++/ Very flexible) to (--/ Highly specialized). Quality of Service. This parameter indicates how much an attempt takes potential data loss into account. Especially in persistent game environments, such as MMOG worlds, the stored data has a high value. The players satisfaction is based on stable data management; less to zero error tolerance is given. The quality of service orientation of an aspect describes the probability to prevent data loss of persistent and relevant data, ranging from (++/ Excellent) to (--/ Very poor). User Behaviour. The user behaviour is an important influencing factor for the evolution of any given game. This assessment parameter represents how much the related work was influenced by user behaviour research. The actual player behaviour decides how games are played online. If the player community does not adopt the game mechanisms as given, then this will lead to completely different behaviour. The level of user behaviour analysis varies between (++/ Excellent) and (--/ Very poor). Hardware Expenditure. Hardware expenditure describes the effort to reduce physical resources needed to realize the given attempts. It contains the necessary expenses for the hardware as well as the opportunities to use other related devices as a flexible alternative. Therefore it can range between (++/ Very high) and (--/ Very low). 37
51 The assessment parameters used above to value the given related attempts are weighed and use the following symbols as given: ++ : Excellent, very high 38 + : Good, high 0 : None, average, N/A - : Poor, low - - : Very poor, very low 3.2 Mobile Aware Games The aspect of mobility in computer gaming offers the user higher flexibility in the choice of gaming locations. Besides the conventional multiplayer aspects over the Internet, mobile (aware) games enable the player to use the application during travelling time. Even the gaming applications themselves can use the mobility aspect to merge the virtual world with the real environment and create new content, socalled wearable or location aware gaming [Bert 2006], [Liu 2006]. However, this gaming attempt also contains some major problematic fields. It is well understood that distributed multiplayer games in a mobile content require a certain degree of support from the network in order to function correctly. Especially real-time aware game types such as FPS or RTS applications suffer from the game relevant effects in mobile environments. Due to the high packet latency of GPRS and UTMS/3G, which can be up to one or two seconds (1000 to 2000ms), FPS and RTS players will notice a significant gap between in-game actions and the game engine. Therefore especially real-time applications are not capable of running under these conditions. As [Clay 2005], [Smed 2002], [Shel 2004] and [Bern 2001] underscore, the latency limit for RTS and FPS games lies between 100 to 150ms (10 to 20 times lower than the provided situation). Even latency robust applications like RPG games show an observable disturbance over 500ms [Frit ]. WLAN and Bluetooth offer a better latency performance of about 50 to 100ms; depending on the quality of the network.
52 Nevertheless, the range of both wireless techniques limits mobility. One would need a completely overlapping network of WLAN access points in order to resolve the latency issue. Besides the influence of latency, games also suffer from jitters. Again especially FPS and RTS applications show significant differences with a higher number of jitters. So-called latency spikes often occur during action-intensive game situations (large fights with a large number of participants). Both GPRS and UMTS offer a wide range and stable network coverage, although it is well known that heavy latency spikes can occur. Local wireless techniques (WLAN and Bluetooth) on the other hand offer a smaller area of network coverage and they also have a major increase in jitters due to local obstacles (the effect of local obstacles is more significant compared to GPRS). Another important aspect for any of the given game types is the network effect of packet loss. In the best case scenario, a lost package only contained movement information which can be restored by using rendering techniques like deadreckoning. The worst case scenario includes game-relevant data like a shot or an important capture. Both mobile network techniques (WLAN and Bluetooth) offer a stable performance, and packet loss is relatively small. However, major data peaks on a single WLAN node can cause a bottleneck and thus create packet loss. Besides the importance of network techniques, mobile devices have a considerable impact on gaming as well. Currently mobile phones, PDAs and commercial gaming handhelds (such as Nintendo DS and Sony PSP) are capable of running high performance games. As [Clay 2005] and [Jane 2005] clearly underpin, there is a significant difference in next generation mobile gaming devices between purely game oriented devices like the Nintendo DS and multimedia handhelds like mobile phones. Due to the vast variety of devices, users are specializing in just one of them, which reduces the number of potential game partners. 39
53 Table 3.1. Overview of network technologies for mobile gaming 40 Technique Advantages Disadvantages GPRS UMTS/3G WLAN Bluetooth High network coverage, scalability, local detection High network coverage, high data rate High data rates, low latency, stable network Very high data rate, low latency, stable network High latency, low data rate High latency, high mobile phone requirements Local coverage, access points, bottleneck, low scalability. Local coverage, obstacles, very low scalability Asynchronous Mobile Gaming Early work in the mobile gaming sector created the attempt to include asynchronous playing. Apart from the mainstream of real-time interaction, asynchronous playing gives the player the opportunity to make the next move time-independently. The best known example is distance chess, where both players take their turn and then wait for the response [Bogo 2004]. By using GPRS or UMTS this attempt can be implemented into a mobile environment as well [Bamf 2006]. This implementation eliminates the downsides of GPRS like high latency, because the applications do not need to run in real-time. With enough time, the packet loss problem is also eliminated thanks to reliable protocols like TCP. In [Bamf 2006] the simple feature of text messaging is used to provide the input for the game. Users participate to create an online novel by further writing the current incomplete story. Those techniques used are easy to implement, although they greatly reduce the number of target applications. Due to the cellular structure of GPRS/UTMS and high availability, the user can generally play wherever and whenever desired. Thus the aspect of mobility as well as time independence is greatly supported by this attempt.
54 41 Figure 3.1. Illustration of the asynchronous game design. The network uses a data server for consistent data backup With regard to the aspect of scalability, one can abstract from the simple 1 vs. 1 distance chess scenario. By increasing the number of potential players, the game mechanisms need to feature at least one interlocking mechanism. In order to keep the game world consistent, it is vital to ensure that each of the players has the latest update. As an example: [Bamf 2006] introduces an online novel, where multiple users can intend to write at the same time, the resulting story would include an inconsistency, because each of the users does not know about the actions of the others. The downside of interlocking is reduced interactivity, a user is only allowed to continue writing the story if no other user is doing the same thing at the same time. Hence, the application does not scale with a growing number of players. The reusability strongly depends on the users behaviour; because of the variety of misbehaviours a single player might acquire negative experiences. An AI (artificial intelligence) can be integrated in order to keep the game running even when players fail to answer for a longer period of time. Although besides the effect of interlocking (a certain player keeps the game stalled by not moving/reacting), there is no on-thefly content evaluation. Generally, a user could send a large number of messages in a
55 short period of time (others would need to read through all of the text to be updated again). Due to the missing factor of achievements [Bart] in the asynchronous games, players are not motivated to cheat the system. This aspect nevertheless bears some severe disadvantages as well. By limiting the variety of genres, one is excluding a major number of potential players; hence creating a special solution that is exclusively usable for asynchronous games. Furthermore, strong focus on pure GPRS/UMTS data transfer increases the gaming cost and excludes several devices (like the next generation handhelds, Nintendo DS and Sony PSP) Near-Field-Areas and Mobile Games One of the most important aspects in gaming is the capability of communicating with the other users. Due to the increase in different multiplayer game types, most of the players will agree that a multiplayer modus certainly enriches the game design. Therefore, the development in the mobile gaming sector is strictly multiplayer oriented (the usage of a single device with a split screen would significantly reduce the playability). As a part of the mobile gaming trend, one aspect is the usage of near-field-area technology such as Bluetooth, WLAN or RFID technology combined with the real world (also called location aware gaming or wearable gaming). The main idea behind the attempt is to integrate one of the available wireless communication methods in order to create a virtual environment that uses the real world. Thus each object (which should be modelled in the virtual environment) needs additional hardware in order to communicate with the player or store necessary information. As one can imagine, there are several ways to implement near-field game zones; each of the technologies varies slightly in communication range, hardware effort and usability. While maintaining generality, this section will delve into the usage of RFID technology as an example of how to integrate gaming in a near-field area context. As previously mentioned, a potential way to integrate mobile multiplayer gaming is the usage of RFID (radio frequency identification) tags [Garn 2006], [Petr 2005], [Coul 2006]. A RFID tag is an object that can basically be attached to a product or person for identification purposes; therefore it contains a silicon chip and an
56 antennae. For gaming purposes, the onboard chip can be used to store game-related data, however, it is necessary to understand that due to the size limitation it is not possible to store a large amount of game world data on the tags. Depending on their size and of course the price, next generation tags do not offer more than a few MB (Megabyte) space. Generally two different types of tags exist: the passive and active tags. Passive tags do not have their own internal power supply, so they need an antenna that is designed to collect power from the incoming radio signal and to also transmit the outbound signal back. The lack of onboard power supply further decreases the size of the tags. The active tags on the other hand feature their own internal power source, which is mainly used to power the outgoing signals. As a result the size increases, however, the reliability of active tags is typically higher compared to their passive counterparts. Current tags vary in size (depending on their antenna and whether or not they are active tags) and signalling range, which is usually 10cm to 5m for passive tags and 20m to 100m for active tags. This attempt relies on the huge market penetration of mobile phones; with over 643 million mobile phone devices sold in 2004 and a forecast of over three billion subscribers by the year 2010, the potential user group is massive [Gonz 2005]. Mobile phones constantly offer more features, integrating a RFID reader to interact with RFID tags is a possible expansion for next generation mobile phones. It is important to understand that common mobile handhelds do not feature a RFID reader, yet integration into the devices is needed in order to benefit from the huge mobile phone market. Hence using RFID, which enables basically every object to be connected to the Internet, creates a completely new network structure. An example scenario for a wearable gaming implementation can be found in [Garn 2006]. This scenario includes virtual spraying on walls, the RFID tags are attached to normal walls and a player who sees one of the tags can use a RFID reader to see which picture is virtually painted on the wall. Furthermore, this picture can be overwritten with an own tag. Sustained motivation for the players is to distribute the own picture to the greatest extent possible. By integrating the RFID tags into the real environment, one uses given structures to expand the game world. One can attach the RFID tags to real world objects; it is possible to create a location aware gaming environment where the minor information in the onboard memory of the RFID tag 43
57 acts as the game world information. Figure 3.2 illustrates the physical design of a RFID tag from [Garn 2006]. Generally, other wearable gaming examples can include different real world objects with RFID tags on them. An implementation of mine-sweeper would use the tags to store information about the number of adjacent mines or would be a mine itself. The players could use the RFID reader to look for mines in a virtual mine field. Possible other scenarios could be Pac-man or hide-and-seek, supported by the RFID technology. In terms of scalability, RFID tags offer the option to generally integrate as many objects as desired into the game world. However, as soon as two or more games use the same technique, it is necessary to clarify which tags belong to which game. Objects can either be marked or additional information from the game provider is required. One can also imagine tags that support different games at the same time, as long as the game mechanisms and the radio signal differ from each other, multiple game information of distinct games could be integrated into the same tag. Another important aspect is that the technical requirements do not scale with the number of players. Assuming that each of the players requires at least one RFID tag in order to be satisfied, the required number of tags will soon pose a problem because when the community is large, especially replacing the inactive or old RFID tags will increase significantly with the number of players. Physical limitations can also occur. If multiple tags are hosted in the same location, objects can already be used by other players. 44
58 45 Figure 3.2. Exemplary picture of a passive RFID tag from [Garn 2006], the tag itself is located within the paper bag on the bottom left-hand side One of the major advantages is the high factor of mobility that is created by the RFID tags. By integrating RFID readers into mobile phones, they can act as the main gaming device in this approach and offer great flexibility. A good example of this trend is the next generation of mobile phones from Nokia, older versions are supported with separate RFID kits (such as Nokia 5140), meanwhile newer models already have an integrated RFID reader [Noki]. Other handhelds can also benefit from this technique; generally PDAs or next generation gaming handhelds (like Sony PSP or Nintendo DS) are capable of RFID tag reader integration; currently such integration is considered as an opportunity for future models. Hence with the required number of tags, a large number of potential players can be supported by merging technology already deployed. The RFID tags also offer suitable reusability for other (gaming) applications. Especially data stored locally can contain information for several games at once, thus using the same device for multiple game worlds. This technique offers a stable network as long as an individual node does not become too popular. Well-known nodes will probably use more energy because they will be updated frequently, thus the rate of replacement will be significantly higher. Also simultaneous access by multiple players can cause deadlocks in a single node. Therefore it is important to
59 physically spread the network and scale the number of RFID tags with the number of potential players. Due to the asynchronous game nature each contestant can use the game network whenever or wherever he/she wants to. The factor of security is one of the disadvantages of RFID tags. By allowing the users to upload data to the nodes, one must keep in mind that the next player will receive this data (this can be prevented by using encryption methods for each game). In terms of mobile phone security a direct data exchange can cause considerable security problems because harmful data can corrupt the mobile devices of other players. Hence a specific solution for a single game can prevent the abuse of harmful data transfer, although as soon as multiple RFID tags are attached to the same object or a single tag features data for multiple games, a more generalized solution is needed. One option would be to expand the J2ME SDK, which runs on most of the next generation mobile phones. If a RFID reader is also supported, the J2ME engine could provide basic security functionalities and therefore offer a general platform to increase the security of the RFID attempt. In concluding the positive and negative aspects of the attempt, the integration of RFID tags into location aware gaming is based on the combination of already existing technologies. Due to the low prices and high flexibility of the RFID tags, the resulting game world can be designed individually. Although one should also keep the limitations like physical space, a missing integration of RFID readers in mobile devices and security in mind Massive Multiplayer Games Another central aspect of computer gaming is the constantly growing number of simultaneously playing users. With the creation of the first persistent online worlds [Ever] and [Ulti], the gaming behaviour of the users changed completely. The current game evolution leaves no doubt about the importance of MMOGs, therefore creating all forms of massive online worlds like MMOFPS (massive multiplayer online first person shooter), MMOSpace (massive multiplayer online space game), MMORPG (massive multiplayer online role playing game) and even UMMORPG (ultra massive multiplayer online role playing game). One of the characteristics of MMOGs is that
60 they usually consist of a virtual world with a time and space concept similar to that of the real world. The research field concerning the massive multiplayer game genre also includes a wide variety of different analyses, mainly focusing on the most important aspects caused by the large number of players. One of these aspects is the efficient distribution of players between the (multiple) servers available. Since MMOGs (massive multiplayer online games) are typically built as a strict client-server system, they suffer significantly from the inherent scalability problem of the selected architecture. Not only instancing (creating an instance [personalized copy] of a zone, only a specific group is allowed to enter the instance) and sharding (creating a parallel game world, which runs on a different server) help to split the player community into manageable masses. As [Lu 2006] shows, an effective strategy for load balancing in between client-(multi) server architecture is required to generate a stable environment even during peak times. Hence distributing the points of interest in-game, such as running several events in parallel or splitting a popular zone up into sub-content further helps to even the loads in between the servers. The so-called ingame interest management [Boul 2006] is one of the most common ways to realize such a distribution. Originally developed in the FPS game research the interest management can reduce the broadcasted data up to a factor of six by only showing the player the relevant objects. A zone of interest is created and only in-game events that affect this zone will be transferred to the player, thus significantly reducing the overall data transfer. Together with pure balancing between the servers, the in-game zones (even in a seamless MMOG) also pose a major coordination problem. The latency for any player interaction increases due to the server s bottleneck character. With regard to player grouping, the analysis of group communication [Vik 2006] offers further support for a more flexible in-game scaling. Therefore, they analyze and compare different algorithms to cope with the increased in-game communication latency and the massive server load. With the growing complexity of online worlds, pure zone balancing (distribution of the persistent online world into different sub-zones) often fails to distribute the game world efficiently. Hence a more detailed distribution is described in [Vlee 2005], 47
61 using a micro cell balancing algorithm. By breaking the game world down into even smaller pieces and creating effective hand-over strategies between the multiple servers, it is possible to further even the loads. Nevertheless, as soon as an in-game attraction motivates a huge number of players to visit the same local area it is still difficult to separate the resulting overload. But fairly distributing the load in between the in-game servers does not suffice for massive multiplayer games. Especially network protocols reach their scalability limits with numbers higher than 10,000 simultaneous players. Server traffic analysis indicates a similar player pattern concerning the daily routine, creating a significantly higher number of packages during the peak times in the evening and on the weekend. A controversy as to whether TCP or UDP meet the requirements of next generation MMOGs is now under way. However, both protocols clearly have advantages and disadvantages [Chen ] Using and Detecting AIs in MMOGs In light of developing MMOGs and their persistent worlds, there was also a need to implement a macro-economy with in-game money and funds. As soon as in-game values became re-sellable by auctioning them online for real money, there was also a huge endeavour to design Bots [Lehd 2005], [Bart 2004] and [Cast 2001]. Bartle [Bart 2004] determined that the persistent world of Everquest was the 78 th richest country with regard to its GDP by calculating it with all potential citizens (players) and their estimated income if they sold their in-game money. Today, the reselling of in-game goods has become a sizable industry on its own with major downsides. A negative example of the reselling mechanism is the so-called sweat-shops. Low-cost workers from third world countries are forced to play online in eight to ten hour shifts every day in order to harness online treasures. These treasures are sold for real money afterwards. In this context, one needs to distinguish between two different aspects of AI usage in MMOGs, the Bots (automated gathering programs) and the NPCs (non-player characters). The automated scripts created by the player are called Bots ; these programs are mainly used to gather in-game resources without playing the game [Chen ]. In most cases, this takes place in a program that takes control over a
62 human character and an automated script that is run locally on the client s computer. It can be quite difficult to predict AI scripts; especially due to low error tolerance (banning a real player would have fatal consequences). Hence many MMOGs cannot cope with the constantly evolving community of automated programs because most of the players are not willing to invest the necessary amount of time to replay the same scenario multiple times. The creation of NPCs enriches the virtual environments; these programs are often part of the online world itself. [Merr 2006] classifies NPCs into three different categories: enemies, partners and support characters. With no loss in generality, this thesis will focus on the detailed description of the support character role. The other two aspects of NPC design differ in their in-game usage, but the underlying implementation methods are similar. NPCs offer a way for players to interact with computer controlled virtual characters, which can, for example, act as a merchant. One possible way to implement NPCs is introduced in [Merr 2006], which shows an interest-based learning design model for realistic NPCs. From a technical point of view the problem in NPC design is their behaviour, they are supposed to behave like humans. In particular, this signifies that players appreciate it if a NPC has its own daily routine like going to the pub in the morning and coming back late at night. Simple actions can be implemented by using predefined scripts (also called reflexive agents), but many online MMOGs also feature complete towns. NPCs have their individual roles in the town, like a blacksmith, merchant, fisherman, etc. A vision for the next generation implementation of NPCs is a detailed interaction between NPCs (also called learning agents). The main difference is that reflexive agents show a static behaviour, whereas learning agents can adopt in-game events and create a new behaviour based on their experience. As a possible example, the fisherman could bring his catch to the cook in order to produce new food for the community (which players could buy afterwards). The players also appreciate social interactions like fights or talks. Especially players with a high social focus, so called socialisers [Bart] will greatly benefit from detailed NPC interaction. With regard to the current MMOGs, most of the persistent online worlds feature more than 1,000 NPCs, mainly to populate the important in-game locations such as towns or dungeons. The scripting of daily autonomous NPC routines is therefore one 49
63 of the major aspects for high quality game content. An improved or automatic algorithm therefore provides the AI with opportunities to greatly increase usability rather than just remaining inactive. These algorithms are more complex versions of simple scripts; their purpose is to allow the NPC to have an individual behaviour. A downside on the other hand is the prohibition of illegal or meaningless NPC behaviour (like committing suicide). One possible implementation method for more complex NPC behaviour is the usage of learning AI scripts, so-called MRL agents (motivated reinforcement learning). The basic idea behind them is that every possible action has its individual rate of interest. Hence the MRL agents use an intrinsic motivation process to identify interesting events. The higher the rate is, the more likely it will be performed next. By performing a task, its interest rates drops, therefore making it more likely that other actions can be promoted to be performed next. As soon as new objects or possible activities enter the interest radius of the NPC, the initial rate of interest will be high, reflecting a curious nature. For example, a player who enters the working area of an NPC would receive its full attention, maybe a greeting or a welcome ritual. The longer the player stays within the area of interest, the more the NPC gets used to him/her. Generally, the agents can continually identify new events about which they would like to learn. The adopted behaviour of a MRL agent is the result of its experience. With new events, the behaviour of the NPC can change over time. With regard to scalability, the usage of Bots and AI scripts clearly outperforms most of the other content approaches. Most of the graphical emotes (social actions that the character can perform like waving and cheering) and movement will be rendered locally, leaving only the location and decision task on the server. Even with high numbers of players, NPCs can still interact seamlessly. Scarce resources such as a merchant s rare materials can either be customized or locked as soon as they are purchased. The attempt is generally also valuable for a mobile environment, especially when the number of potential human players in certain areas is low. However the world consistency, especially due to the influence of the NPCs, can pose a problem in massively distributed mobile networks. This can be exemplified by the merchant of a rare resource who offers it to a player in area A and then another 50
64 player in area B also requests the same resource. If the game world is not interlinked, this can lead to an asynchronous status. The reusability of the AI attempt in the next generation of games is appropriate because it offers a generic framework, leaving decisions (like the rate of interest erosion or the selection of potential behaviour) open for the concrete game design. Nevertheless, one should keep in mind that security and player behaviour are the major disadvantages of the AI approach. As soon as a player has the opportunity to influence a NPC, this can certainly lead to destructive behaviour like luring or blocking an important NPC to annoy fellow players. Also the regulations of tolerated behaviour should not extend reasonable boundaries. No player will be satisfied by following an important quest NPC for an hour and playing hide and seek, while back-tracking its trail over the whole city. The usage of commonly shared NPCs requires a server-client network, leaving fewer opportunities for an alternative solution. As the example of the mobile gaming sector indicates, the concept can be transferred in general, although one should keep in mind that inconsistency or cheating opportunities will increase significantly when doing so P2P Architectures in MMOGs The common MMOG architecture uses a classic client-(multi) server model. Nevertheless, there are also other opportunities to create scaleable and persistent online environments. As [Hamp 2006] and [Assi 2006] introduce, the usage of advanced peer-to-peer mechanisms can also create a distributed online world. This concept of a P2P MMOG structure offers architectural support for a large number of players. In order to support a stable game world with persistent data, the authors combine existing attempts. The DHT (distributed hash table) Overlay-Network uses Pastry [Rows 2001] to achieve robustness against potential network failures. Therefore both the communication and persistency rely on the Pastry infrastructure. Additionally, the object management includes a separate technique called PAST [Drus 2001]. This extension of the basic functionalities of Pastry is required to build an in-game consistency. Especially with regard to the importance of persistent character data it is
65 absolutely essential to have high reliability by replicating the objects. The worst case scenario for a MMOG is the constant loss of persistent data, because this will lead to a significant loss of players. The only known example is a complete server crash at the SOE (Sony Online Entertainment) labs in California, which was caused by a hurricane. No official data about the long-term customer loss have ever been published, but afterwards SOE decided to maintain an additional server data backup in a different location in order to reduce the chance of losing persistent data again. The third part of the architecture includes the event-based messaging system Scribe, which enables multicasting in the pastry architecture. Important game events (depending on the area of interest) will therefore be routed to all potential peers. Figure 3.4 illustrates the combination of all three techniques for the architecture. With regard to scalability, the approach offers a significant reduction of the overhead caused by simple broadcasting, which would basically announce every game event to all other clients. The Pastry architecture allows the system to find related peers more effectively and thus reduces the path length (which describes the routing length that a single packet needs to travel to reach its destination). The results included for ingame load balancing indicate the support of even a large number of clients. Often in-game neighbours are highly distributed in the real world and thus it is important to reduce the average RTT (round-trip time) for a packet and the included peers as much as possible. The best case would be a network that knows about its physical structure. With this additional knowledge it would be possible to select the shortest path for each communication. 52
66 53 Step 3 Figure 3.4. Illustration of the combination of different technologies to accomplish object access and synchronization in the P2P MMOG architecture: The search algorithm includes Pastry [Rows 2001], the file access is done by SCRIBE [Cast 2002] and PAST [Drus 2001] Mobility still appears to be a problem with this approach, even by using the different techniques to balance the load and minimize broadcasting overhead. A P2P structure still creates significantly more traffic for a single client compared to a server-client structure. The decision about the network type highly depends on the game itself: a game with a lot of persistent data will prefer the classical server-client architecture. The number of players also influences the network decision because even with the progress in distribution techniques, P2P networks do not scale with an improving number of players. Thus the P2P approach offers a flexible solution for a lower number of players with mainly non-persistent game content. The reusability is excellent and the hardware expenditure is also quite good because the architecture can also be applied to different devices. Even the next generation in games could use the existing network layer in order to create a new persistent game world. One of the downsides for the constantly evolving MMOG sector is that older games will probably have insufficient peers to distribute the data. With a decreasing number of potential players or a growing number of inactive peers, the game architecture fails to ensure data storage of persistent game information.
67 The drawback of a P2P-based MMOG architecture is the quality of service. Especially when using commercial pay-to-play mechanisms, an authentification server is absolutely essential. Furthermore, by allowing the clients to spread data one cannot ensure that groups will abuse the system in order to either harm other players or to obtain an in-game advantage. The problem of cheating is described in [Izai 2006], especially with regard to group cheating it is nearly impossible to prevent user abuse. Several time-related cheats can be minimized, but especially instanced areas or loot distribution (duping [illegal copying of an in-game item] or the creation of personalized items) can be massively influenced by the players, assuming they cheat as a team Public Server and FreeMMG A similar attempt is the creation of hybrid structures in order to reduce the overall bandwidth requirement for the provider and to use as many external resources as possible by keeping the internal security level as high as possible. Examples of these trade-off design attempts are described in [Cham 2006] and [Ceci 2004]. The public server attempt assigns the most important functionality (billing, authentification) to the publisher; meanwhile the in-game activity (movement, fighting, and environment interaction) is spread among public servers. Figure 3.5. A FreeMMG architecture, the publisher still hosts the billing and authentification server [Cham 2006]
68 Figure 3.5 illustrates the general game design. The underlying architecture is similar to the FPS public server structure. Important in-game decisions are still strongly influenced by the central loot server (also provided by the publisher). However, a significant amount of in-game broadcasting will be transferred to the local public servers. So-called in-game tokens enable a player to buy permanent items from the loot server, each player earns them by being active on a public server (overall time counts). With regard to scalability, this system strictly reduces the maximum number of simultaneous players. Even strong public servers can only handle a very limited number of players at the same time (example: Tribes 2 with up to 200 players [Trib]). Thus grouping and social interaction will also be reduced because players might not be able to join in the same target server together. Several MMOGs offer a large endgame (the game content for experienced players with in-game characters on the highest level) raiding content; hence the design would not fit the necessary requirements (40+ players attempting to simultaneously reach an in-game goal). Furthermore by highly distributing the game world, the resulting game environment loses its persistence. The aspect of mobility also appears to be supported insufficiently. Especially in a mobile environment, the effects discussed will increase. It is unlikely that mobile servers will exist, because keeping the mobile players synchronized with Internetbroadband users will lead to an unequal distribution of latency. Thus especially in a competitive PvP environment, mobile users will have major disadvantages. Reusability is high for the next generation of games. As long as the in-game content fits the required specifications (which are: no PvP, a highly distributable game world, a server client version that can run on public servers, etc.) the public server bandwidth can be reused for the successor application. Furthermore, by maintaining the most valuable functionality on the publisher s side, the attempt generates a high level of service quality. Persistent data can be stored on the main server, which reduces the probability of data loss. Another important aspect is that the public servers can offer a better connection due to closer physical routing. Hence each player can choose his/her server to optimize network performance. The hardware expenditure is comparably low due to the classic server/client structure. It shows that 55
69 no effort was made to reduce the necessary physical resources. Especially with lower available bandwidth (current MMOGs need at least 8 kb/s) and the reduced performance of mobile gaming devices, the architecture introduced cannot just simply be transferred to the mobile gaming sector. The major disadvantage of the public server attempt is the lack of an evaluation of player behaviour. Distributing the game data to public servers triggers a significant risk of promoting player cheating due to data modification. Furthermore, rewarding the overall online presence with better in-game items also leads to a strong motivation to use a BOT program (third party application, which acts as an automated program in-game) or being AFK (away from keyboard), because rewards are no longer directly achieved by playing in the online environment, and instead they are given for online presence. Especially the aspect of group-related cheating is further promoted by giving the players a common area to exclusively meet as a group (their local server) Gaming Middleware Another method to handle recurring problems (see Section 2.4) is the design of a middleware application for games. Generally, a middleware application is computer software that connects software components or applications. The usage of such an application should reduce the complexity of the remaining problem (in this case game design) in order to provide the basic functionalities. As a result, the programmer of the game can focus on the remaining game-specific implementation (like game design or content). The general idea behind a gaming middleware is illustrated in [Kane 2005], showing an example of how to reuse a significant number of game binaries. The design of a middleware application is not strictly limited to supporting already existing functionalities. For example [Tang 2005] features a free ranking system that offers games a method to integrate new aspects into a player community. As both examples show, the field of potential middleware sites varies substantially. Thus the applications are not only limited with regard to improving the network layer with game-specific functionalities.
70 With regard to the high individuality of gaming applications one should also take into account that multiple middleware applications could support the game at the same time. They do not need to be mutually exclusive as long as each of them solves the problem without interfering with any other middleware applications. Hence the architectural concept should be kept as generic as possible (therefore supporting a high reusability). Especially in the mobile game environment with a high number of game clones, the existing middleware applications could often be reused. The major downside of the very specialized game requirements is the fragmentation into sub-problematic fields for each of them. Thus a single middleware application that supports all game types will produce a large overhead in order to solve every possible game-related problem. In most cases, especially with resource scarce devices, such a general solution will therefore be ineffective due to the massive data overhead. Furthermore, the next generation game design is not completely based on the usage of middleware applications. A successful game can still be create by using no middleware at all. With regard to the substantial upturn in costs for game design (especially in the MMOG sector), reusing effective solutions provides a method to minimize the costs. Another valid argument is the higher development time due to increased beta-testing (beta stage of the software lifecycle in the game production) and large in-game content requirements. By relying on existing solutions like middleware applications, one can focus on the game content and balancing (equalizing the in-game mechanisms, for example by adjusting each of the available classes so that none of them is stronger than the others) Middleware as a Service Platform The considerable investment for the hosting infrastructure of MMOGs is addressed in [Shai 2004] and [Sing 2004]. The origin of the attempt in [Shai 2004] is the risk factor of creating a complex server network for the persistent online world, when the game success is hard to predict. Especially in 2005 and 2006 the MMOG market witnessed tremendous change by creating the second generation of MMORPGs (Everquest2 and World of Warcraft), therefore increasing the development costs to multiple millions of dollars for each game.
71 The service platform attempt aims to create a shared, on-demand platform for online games. By supporting the publisher with open standards and further utilities for game development, the overall costs should be reduced. 58 Figure 3.6. Illustration of the MMOG platform for content control and central game development in [Shai 2004] Figure 3.6 features the architecture of the platform, the provision manager and the potential pool of game servers. The game server pool is basically the underlying hardware; a publisher can lease a certain number of servers that are capable of running the game world. The other important middleware aspect is the MMOG platform, which has a database for common game content. As a connector, the provision manager enables the game servers from the server pool to access the gamespecific content from the platform, therefore the game content complexity can be increased by reusing a pool of common quests. The administrative service redirects the clients to their server and if needed provides them with content from the platform. The design of the platform is kept as general as possible in order to support the basic game functionalities (for different game types). By requesting resources of the game
72 platform, a publisher will receive as many servers from the game server pool as necessary to host the game world. Depending on the game type in the MMOG sector, the required hardware can differ. For example, current MMORGPs require a large server performance to keep the persistent online environment running at all times. Other games like MMOFPS require significantly less capacity due to the smaller environment. With the service platform a provider can reduce the risk when launching a MMOG by receiving an individual server support as well as the required functionalities of the MMOG platform. The scalability server attempt is based on a brute force technique; with a major increase in player numbers a large server cluster is needed. Other MMOGs (like Eve Online) handle the increasing number of players due to an intelligent server structure and do not only compensate them because of the integration of additional hardware. Furthermore, the MMOG platform also generates additional overhead by providing functionalities for content and player management. Common techniques like sharding can be used to split the online environment up into similar server clusters. However, using the server resource pool to support cross-functionalities in between the different shards is not explicitly mentioned. A highly loaded server could therefore use the bandwidth of a low populated server by deploying a common game instance server. With regard to mobility the attempt does not support mobile gaming; the focus relies on massive multiplayer online game environments. Especially the aspect of reusability is mainly addressed by creating a platform with functionalities for different game types of MMOGs. Hence the server pool is a flexible way to assign required bandwidth to the applications. Even successors of the current game generation could adopt the interfaces used and thus reduce the overall amount of required development effort. The major disadvantage of the attempt is the lack of quality of service and the high specialization in hardware expenditure. Therefore, regular backup strategies will ensure that a re-rolling can be carried out in extreme cases. By outsourcing the infrastructure to a third party application, this leads to a higher probability of data loss. Also the very specialized structure of the service platform excludes mobile- or 59
73 P2P-based attempts. User behaviour is not addressed at all, leaving cheating or bypassing login servers unmentioned Middleware Example: OpenPING Middleware In contrast to the general middleware application for different game types, several attempts aim to create an in-game middleware support. As an example: [Okan 2004], [Akka ] and [Akka 2004] address different methods to integrate third party applications into the game. One of the major advantages is the resource speciality of any of the given attempts. By reducing the number of potentially supported games, the required data overhead also decreases significantly. Thus specialized applications are capable of coping more effectively with the game requirements. The OpenPING in-game middleware in [Okan 2004] offers several interfaces for potential base programs that cover the basic game functionalities. Furthermore, it supports meta interfaces in order to adjust the implementation strategy by focusing on the game requirements. Figure 3.7 illustrates the example of the OpenPING in-game middleware application that runs on the game kernel. In contrast to the service platform, this attempt aims to integrate the middleware into the game application. The base interfaces offer a flexible solution for current MMOGs, including the general in-game functions (like move, send, attack, etc.). Additionally, the meta interfaces allow third party applications to enhance the game further, an example for such an application would be an improved GUI or AddOns (small programs) that a user can install. The OpenPing middleware interacts with both the basic and the meta interfaces and creates the basic rules for each external program. The commands from the interfaces are translated and sent to the game kernel (game engine), where they can be executed.
74 61 Base Interface Base Program #1 Base Program #2 Base Program #n In-Game Middleware Meta Interface Concurrency Application Events Meta Program #1 Replication Interest Management Consistency Meta Program #n Game Kernel Execution of in-game events Figure 3.7. Design concept of the OpenPING platform. Inner structure and outer relations towards meta and base interfaces are shown in the diagram [Okan 2004] The system design of the OpenPING middleware focuses on the aspect of computational reflection [Smit 1982], which ensures a uniform program structure. Based on a classification of application object behaviour, the middleware application will predict possible events, hence reacting in time and supporting the game application with the necessary resources. For example, a large number of players gathers to attempt a fight against an important NPC. In this situation, the middleware could anticipate the requirements of additional resources for the next few minutes in order to support the game with necessary bandwidth and server performance. With the interfaces for further meta programs, the middleware can be extended with additional features without losing its inner consistency. Especially for a MMOG with regular updates, a generic update of the middleware ensures that the current predictions are still effective. With regard to scalability, the middleware offers the design of light-weight applications to predict the players behaviour. Nevertheless, due to the complexity of persistent online worlds an empirical testbed is missing, therefore the prediction with
75 very large number of players (10000+) is not documented. Another important aspect is the additional computation time that would be required to predict each possible event. Especially with a seamless online world, handovers between zone servers also need to be taken into account, hence further increasing the complexity. The focus towards in-game middleware application for massive multiplayer online games results in a missing mobility factor. However, other related projects aim to support the mobile environment with a fitting J2ME-based middleware solution like [Pell 2005] and [Open]. Furthermore, due to the high specialization, the reusability of each in-game middleware application is low. Only a possible successor could re-use the existing interfaces if the game design is related enough. Nevertheless there are certain advantages as well, like the high quality of service. By focusing on a single game and implementing a middleware application, this can further support the effect of persistent data backup. By predicting important in-game events, an asynchronous backup can be carried out, thus further reducing the probability of losing important data. For example after receiving an important item, an individual character backup would ensure that this item cannot be lost if the server crashes. The in-game architecture also includes potential user behaviour, creating reactions for in-game events. By effectively predicting the behaviour of a user, the game content and the in-game stability can be improved significantly. Although the additional effort for calculation requires hardware and more user information (position, last item used, last action, etc.). Hence the hardware expenditure is rather limited, excluding resource scarce devices and highly distributed mobile environments Patch Scheduling and Middleware Support This attempt [Cham 2005] offers a middleware solution for different MMOGs. In persistent online environments, the player numbers vary depending on the real-life time. This variance leads to a recognizable difference in streaming bandwidth during the different days of the week. By ensuring that the client software is continuously updated, the game provider needs to patch each client when in-game changes have been made in order to prevent cheating or asynchrony.
76 63 Figure 3.8. An overview of the required bandwidth with regard to the time and the day exemplified by a Counter-Strike server from [Cham 2005] Figure 3.8 illustrates the basis streaming bandwidth of a Counter-Strike server. The authentification tool is called steam, which gives each user a unique ID and uses check-sum techniques in order to ensure that the local data matches the newest patch. The example of Figure 3.8 shows a popular US server and its upload towards the steam tool in MB/s. As one can clearly see, a daily routine exists because the peak times (afternoon and early evening) feature a generally higher level of required bandwidth. Additionally, on Monday a new version of Counter-Strike was released and the clients needed to update their local version. The resulting effect is that the average bandwidth as well as the peak bandwidth on Monday and Tuesday increased considerably. Patching the client creates a significant amount of further bandwidth that is needed to support each user with the newest software update. Therefore, a middleware application in [Cham 2005] introduces how to distribute the additionally occurring bandwidth overhead. The application automatically scales the amount of potential bandwidth with regard to the overall number of downloading clients. Hence, it reduces the peaks during the first hours after the new update has been released and encourages players to wait for a few hours in order to receive a better performance.
77 It is also conceivable that a multi-agent attempt can be used [Bare 2006] or a P2P system to distribute the new update, although this can lead to a significantly increased chance of abusing the P2P data exchange by uploading modified data. With regard to scalability, the attempt offers a self-regulating mechanism to scale down all currently downloading clients. The more clients downloading the update simultaneously, the less bandwidth they will receive, even if more potential might exist. Hence this attempt is scaling with two effects: first of all, some clients will avoid the peak hours after the patch release, which will smoothen the request rate during the first few hours. The second effect will be a public server mirroring by the gaming community; they will probably create further servers to download the current patch. Thus the patching mechanism will smooth the distribution of the additional bandwidth, although less bandwidth can also lead to negative feedback because many users are not willing to wait until they can play again. This negative effect reflects the low inclusion of player behaviour analysis in the bandwidth attempt. Neither mobility nor quality of service is explicitly addressed in the attempt. It is possible to use the given method to distribute data in a mobile environment as well. Depending on the cost structure (pay per minute or pay per data rate) it will either not improve the given situation at all or it will even make it worse by reducing the potential data rates. The reusability of the patching middleware is supported due to the generic design structure. The problematic field is similar in most of the current MMOGs, especially in the most frequently played games Player Behaviour During the last five years, the aspect of online communities and social interaction has achieved significant importance for the game design. Most of the successful publishers realized that integrating the player community into the creation process is a necessary step in order to create long-term relationships with each customer. Hence the quality of in-game content clearly became more important. Due to the creation of persistent online environments it was necessary to expand the balancing and quality testing software phase. One result is the creation of beta test periods that allow the publisher to gain a better understanding of the current game quality.
78 Another important aspect is the interaction in virtual environments (VEs) as described in [Mann 2000]. By spending a considerable percent of leisure time on the MMOG, the players begin to set up their own language and behavioural rules. If the game does not offer sufficient support, then the community often looks for ways to improve the current situation. For example, a missing trading system in a MMOG is often bypassed by forums or the creation of special channels. On par with the players motivation, [Klas 2006] illustrates why it is important for a publisher to build up long-term relationships and to listen closely to the community s needs. However, not only does the player behaviour influence the creation process of modern game design. As [Vill 2006] illustrates, each of the games also requires a very specialized input, often twenty or more keys are used to send game engine commands (mainly movement and actions). Thus the input device addresses the need for a flexible way to support the users needs. As the results show, it is possible to further improve the quality of games by changing the input opportunities. Furthermore, [Seha 2006] also introduces methods for alternative execution control with regard to player opportunities. Although player behaviour often strictly refers to electronic computer games, there are also methods to integrate real world devices into gaming. The example of air hockey over a distance in [Muel 2006] shows the importance of user comments and behaviour for the development of new game mechanisms. Strategies to improve the design of an air hockey table were addressed by listening to the test players, a clear similarity to the beta testing phase of MMOGs. One of the largest issues addressed by the users was the feedback of the air hockey table. As soon as the perception of a player does not correlate with the output of the game engine (whether electronically or physically), the user will try to interpret the situation and learn from possible mistakes as [ElNa 2006] shows. In the example of air hockey [Muel 2006], the devices were not accurate enough, hence creating a distracting situation Cheating in Computer Games One of the most significant problems addressed in the research field of player behaviour is cheating. In order to understand the motivation of a cheater one can use the taxonomy of Bartle [Bart] to analyze the players goals. Nevertheless, there are
79 many more reasons to cheat; the main motivation is the fast success. Therefore, the first step towards protecting the in-game environment from cheating is to analyze existing methods of corrupting the game, as listed in [Yan 2005]. Most cheating is either based on third party applications or on delaying own actions as long as possible to react to potential actions of other players. An example of a large-scale cheating history can be found in Counter-Strike [Coun]; the high level of competition and the relatively old game engine results in an extremely professional and sizable cheating community. Methods to protect especially FPS and RTS games are introduced in [Agga 2005] and [Mönc 2006]. Generally, a P2P environment with distributed game data is more vulnerable for cheating attempts than classic server-client architectures. Therefore it is risky to use one of the different attempts in order to implement P2P or hybrid structures in a massive multiplayer environment [Kabu 2005]. The advantage of lower overall bandwidth for the publisher can lead to an expansion of the cheating community on the other hand. The attempt to realize new game mechanisms without enabling the players to abuse them for their own advantage is introduced in [Smed 2004]. The new game effect of bullet time, referring to the slow-motion used in [Max] Max Payne and [Ente] Enter the Matrix, is included in a multiplayer environment. By slowing the environment down for a player, the user has more time to react and can perform more accurately. Hence the implementation of a local perception filter enables the environment of a single player to be slowed down by using temporal distortions. The corresponding game effect is a significantly slower environment for a single player while the rest of the game environment runs in real-time. The individual zones of temporal contour are shaped like a cylinder, as shown in Figure
80 67 Figure 3.9. Figure of a 3D illustration of two virtual players with linear delay functions in order to build a temporal contour (necessary to realize slow motion and bullet time effects in multiplayer games) [Smed 2004] Although each of the players has their own perception of the game world and temporal asynchronies are allowed, the effect of bullet time can be limited to a single player. However, the longer the effect is active, the more frequently differences between game states occur. With regard to scalability this attempt has a major downside. Due to the limitation of the local filters, players cannot interact directly with one another. Rather, all of the interaction takes place by using passive entities, thus the closer a player gets to another one, the larger the temporal distortion becomes. Usually, player interaction increases with the number of potential other players, in MMOG environments the users tend to distribute unequally. Especially in MMOFPS with multiple dozens of simultaneously acting users, the effect of temporal distortion will not scale with a growing number of players. The aspect of mobility is not addressed in the attempt. The assessment parameter hardware expenditure is high because the resources needed to calculate the effect of bullet time can be calculated on the client s computer. Generally, it is also possible to use the asynchronous game concept in networks with higher latency as well. However, by limiting it to a specific genre and a very specific game engine design, it is not possible to reuse the attempt for many other games. Implementing the effect of bullet time in a multiplayer environment requires significant conceptual decisions, thus making it hard to transfer to other game genres like MMORPGs.
81 Both aspects, user behaviour and quality of service, are addressed as the main focus. By implementing a non-existing effect into a multiplayer environment, the attempt generates a new way to interact in virtual environments. By strictly limiting the bullet time effect to the local perception of each user, the attempt avoids data loss due to game inconsistencies Categorization of User Behaviour The categorization of users and their behaviour has become a research field for game development over the last few years. The main goal is to understand the motivation of a user and therefore predict possible behaviour. Most of the current classifications are based on the taxonomy of Bartle [Bart], who divided players into achievers, socialisers, explorers and killers. Many further effects like third places in online worlds [Duch 2004] could be explained by using the model s motivation factors. The creation of test environments for specific game types further enables the underscoring of how important effects like latency, jitter or package loss are. The highly varying requirements of each game type influence the players reaction; hence each of the games has its impact on the level of influence with regard to the users performance. Examples for the measurement of user performance are shown in [Beig 2004] and [Shel 2003], evaluating the FPS and RTS game types. Both attempts underpin the importance of user behaviour for network researchers. To gain a deeper understanding of the player interaction in MMOGs, the attempt in [Chen 2006] focuses on the analysis of network traffic. By comparing real world locations with in-game locations and behaviour (such as team setup, friends, etc.) it is shown that neighbours and team mates tend to be closer to each other in the network topology. The Venn diagram in Figure 3.10 attempts to understand the mechanisms for this correlation. Generally, every player can be seen as an independent actor, sub-groups are solo players or socially interacting players. It is important to understand that a single player can have attributes of more than one subgroup, depending on the situation and game. For example, a user could be strongly group oriented in a MMORPG and additionally plays a FPS just for fun. During the game time in the FPS, the user wants to play alone. This example would illustrate different behaviour, which is based on the game type.
82 69 Figure The Venn diagram for player classification: The main focus relies on group vs. solo motivation [Chen 2006] The attempt classifies online players into sub-groups with regard to their in-game behaviour (for instance neighbour, partner, etc.). The game time, session length and online behaviour of each sub-group is analyzed separately. The idea behind the diagram is to analyze whether several users, which are locally neighbours in the real world, also have similar online behaviour. An example of group players would be several users that live close to each other and who started to play a MMOG on the same server. By evaluating their behaviour one can predict needs, an advantage of this technique is that a publisher might want to know how the user group is distributed. Game servers near the location of the majority of users would help to increase the game performance. Within the section of user categorization the attempts towards game type-specific analysis are strictly limited to either the game or the related game type. Hence, the attempt [Chen 2006] focuses entirely on a medium-sized MMORPG. The results of local player aggregation and the closer position in the network topology can be a social effect of the Asian gaming culture. Furthermore, it is unclear if this effect will remain stable with regard to an increasing number of players per realm. The attempt does not include the aspect of quality of service, like a data management or game quality for the analyzed players. Furthermore, the strict focus on a serverclient model and a massive multiplayer environment also excludes the factor of mobility. Although technically, it is possible to gather local neighbours by using the
83 cellular structure of mobile phone devices (GPRS/UMTS) and to design sub-groups depending on the physical position. Nevertheless, the main focus of the attempt relies on the user behaviour analysis. Based on the Venn model, the statistical analysis clearly indicates that the distribution of the current player community does not allow further clustering or local fixed-sized partitioning. Additionally, the attempt offers an opportunity to analyze bigger MMORPGs in another social environment in order to compare the results. Therefore, a reusability for future surveys containing MMORPG player behaviour exists Game Influence in Real Life In order to understand the external effects described in [Mysi 2006], one must first be aware of in-game interaction and the design of a social culture. Persistent online environments have created a completely new form of interaction rules, as shown in [Jako 2003] and [Chen ]. The social interaction in MMOGs [Chen ] therefore turns out to be the major influencing factor, especially if the user spends a large amount of leisure time playing. By creating new virtual spaces (persistent online environments) the social interaction in between the generation of gamers changes fundamentally. A topic that has often been addressed in the media is the influence of gaming on reallife behaviour. It is known that frequent behaviour has an influence on human socialization. Hence, hardcore gamers with only a few or no other real-life activities besides gaming are very likely to easily adopt the virtual behaviour. Especially games with content focused on violence are often considered to be a major influencing factor for people to perpetrate heinous crimes. Positive and negative external effects are evaluated in detail in [Mysi 2006] and [Fran 2006] in order to analyze the significance of influence. Frequent game playing does not only have negative effects. A list of possible positive effects for frequent users of MMOGs is evaluated in [Fran 2006]. The research focuses on the increase in typing capability and knowledge acquired by playing a MMORPG. However, the observed behaviours and skills are very closely linked to the usage of computers; it is understandable that by frequently using the
84 keyboard to communicate with others, the typing skill will not decrease. Also the increased in-game knowledge is clearly addressable for the players basic motivation to understand the game mechanisms and improve his/her character. However, it is also shown that other non-related positive effects occur like increased potential to use the Internet for research. It has been statistically shown that the increase is stable over time and leads to a deeper understanding of using next generation media. Social interactions with other players have also been observed in depth and common behaviour [Chen ] has been frequently adopted by the new players. General social rules were accepted and even further transmitted to other players. With regard to scalability (statistical scalability of the method used and not network scalability), the attempt is aimed at a very limited number of test subjects. Hence, the evaluation focused on pre-selected targets which seemed to hold no or only a little potential for extraordinary real-life behaviour. The attempt did not focus on the mental state of each participant and the major player community as targets. The methods introduced to gather the required players data clearly does not scale with a larger number of participants. Also the game structure for the attempt was a common server-client MMORPG, therefore not taking mobility aspects into account. The attempt does not include the underlying architecture or devices used for measurement (except for the keyboard), which slightly limits the possible input devices. Furthermore, quality of service mechanisms or data management was also not included. By losing permanent game data like characters, it is most likely that many players will quit the game. The major focus relies on the user behaviour analysis; with verified results and more influencing factors it would be possible to determine whether long-time correlations between effective usage of modern communication structure and online gaming exist Summary Varios attempts have been presented within the related work section. Each of them mainly focuses on one of the four central aspects: mobile gaming, massive multiplayer gaming and middleware design as well as player behaviour analysis.
85 Due to the complexity of the set of problems, most attempts offer a single solution for a specialized problematic area of next generation game design. Especially the MMOG section features various aspects that cannot be easily resolved (like latency, scalability and combination with the mobile environment). Nevertheless, each of the attempts is kept as generic as possible, therefore supporting a larger number of potential games. Table 3.2 gives an overview of the attempts in the related work section and illustrates the advantages and disadvantages with regard to the assessment parameters: scalability, mobility, reusability, quality of service, user behaviour and hardware expenditure. 72
86 Table 3.2. Assessment of the related attempts, using the six game-related factors. 73 Scalability Mobility Reusability QoS Mobile Aware Games User Behaviour Hardware Expenditure Asynchronous Mobile Gaming RFID Tags Massive Multiplayer Games Interest-based AIs P2P MMOG Architecture Public Server Architecture Gaming Middleware Service Platform OpenPING Middleware Patch Scheduling User Categorization Bullet Time in Multiplayer Player Behaviour and Design
87 74 4. Approach I: Understanding Player Behaviour The right word might be effective, but no word was as effective as a rightly timed pause, Mark Twain. This chapter introduces the player behaviour approach towards the current gaming situation. Hence, the underlying architecture of the survey database as well as the online questionnaires Distribution of Online Player Behaviour and Virtual Fragmentation are introduced. This description includes the operationalization and scales used for the creation of the surveys. Furthermore, the advertising strategy and selection of the user group is explained in detail. 4.1 Motivation and Overview Today, the Internet features over 120 different MMOGs with various settings and scenarios. That even includes new game types like UMMORPGs or MMOFPSs. All of them have a common factor: one player always represents a single character (toon) at a time. Thus the identification with one s in-game character is significantly higher than when compared to more dynamic games like common FPS where the in-game character changes more frequently. This leads to the question of in-game behaviour. With the release of the first MMORPGs, both the player community and their way to play games were completely unknown. The so-called first generation MMORPGs were played for various reasons (such as having the opportunity to play in a persistent online world and new character evolution depth) [Lazz 2006]. Thus discrepancies of the players lead to their game demeanour [Jako 2003]; second generation MMORPGs subsequently featured player guides and dictionaries for in-game etiquette and speech to give the new audience an insight into the online worlds. Furthermore, the more experienced players from the first generation MMORPGs also created an informal set of behaviour rules that influenced newcomers. Like in real environments, players needed to find a common way to interact with each other. The
88 changes mentioned also entail the question about how much of the real player attitude actually remains. Another important aspect in persistent online games is the influencing factor of competition. Depending on the players motivation [Bart 2004] this factor varies highly from one person to another. The aspect of competition can generally be divided into solo/group competition and PvP/PvE competition. Table 4.1 gives an overview of the resulting combinations from both dimensions with a pair of example games for each section. 75 Table 4.1. A two-dimensional illustration of competition possibilities PvP Competition PvE Competition Solo Competition RTS Warcraft III FPS Quake Classic arcade games or browser games Group Competition Tactical FPS Counter Strike RPG Guild Wars RPG Everquest2 Solo competition describes the gaming style of a single player who aims to reach the highest possible score compared to other single players. It does not necessarily imply a pure 1 versus 1 situation; therefore the classic death match (a free-for-all game mode where each player fights against the rest) would also be classified as a solo competition. The solo aspect rather refers to a prohibition of teaming between rivalling players. A common example of solo competition is RTS. The game engine takes on the role of a judge and thus either allows or prevents actions. Moreover, the term of game balance is important for competitive games. Figure 4.1. The solo competition the game engine acts as a judge
89 Group competition on the other hand includes the explicit creation of a team to fight against another team. Two or more pre-arranged teams are trying to reach a goal. The single player acts as a part of the team; winning or losing no longer only depends on the single person. Additionally, the game mechanisms change fundamentally when compared to a solo competition game. The idea of a role distribution (like healer, damage dealer and protective class), with individual task fields, gives the group competition a higher level of complexity. Most of the current competitive SG and FPS feature group competition as the main multiplayer element. 76 Figure 4.2. The group competition an example of two different groups competing A totally different classification is carried out by the dimension of PvP vs. PvE competition. This has nothing to do with the above-mentioned solo vs. group competition it is a completely different separation. PvP is the abbreviation for player versus player. By demonstrating higher scores or kills one user wins. Examples of that are typically 1 vs. 1 FPS games or RTS games. Once the game is over the results can be saved; meanwhile playing is simultaneous (both players need to interact in the same virtual environment). The requirement of simultaneous gaming excludes asynchronous games like browser games, that feature a high score table. Generally, a player needs to interact directly with other human opponents in a PvP situation. For example, two clans are fighting against each other and the results are saved in a ranking system, as shown in Figure 4.3. Exceptions
90 from this rule exist, although for differentiation in this thesis, the PvP aspect focuses on the direct player interaction. 77 Figure 4.3. The PvP competition the game runs simultaneously: Afterwards the results are saved on the server In contrast to the direct comparison of skills against other human players, the PvE competition focuses on achievements (i.e. reaching something most effectively/the fastest/first). Player versus environment (PvE) implies that the opponents are controlled by the computer (AIs). A good example of a PvE challenge is the unique boss-type in MMORPGs that require multiple players to team up in order to eliminate them. The aspect of challenge in this context means that the players do not play directly against each other. Rather they work on a goal set by the game environment. Whoever reaches this goal first wins the competition. Saving Score Saving Score
91 Figure 4.4. The PvE competition the game runs in two different instances and asynchronously: after both players/groups have completed their tasks, the results will be saved on the server 78 Typical examples of indirect PvE challenges are MMORPGs. The game world is divided into instances, which mirror the same encounter (the challenge) to different groups of players; speed and efficiency are measured and compared afterwards. Figure 4.4 illustrates the situation. Especially with regard to the time invested in a single game, pro-gaming (professional gaming) is one of the most recent results of the increasing importance of video games in multimedia entertainment. The first professional gaming scene was developed in Korea, where players earn money for professional electronic sports competitions. With the increase in network technology and multiplayer game support, each of the competitive game types (RTS, FPS and SG) established their own pro-gaming tournaments. Up-to-date tournament series like CPL (Cyberathlete Professional League) or ESL (Electronic Sports League) feature a wide variety of current competitive game favourites with total winning prizes of $100,000 and more. These high values once again reflect two important facts: the growing acceptance of gaming as a sport and the interest of sponsors to reach even more players. Sweat-shops on the other hand are the downside of the growing importance of games. Virtual worlds often contain goods such as items or treasures. With the tremendous success of persistent online worlds these goods received real world values [Mann 2000]. ebay and even the game companies themselves offer an easy way to sell these virtual goods. As a result of growing interest combined with real world values, third world workers are playing in so-called sweat-shops in eight to 12 hour shifts in order to receive resellable virtual goods. The publishers of the MMOGs react in different ways. Sony Online Entertainment, for example, opened its own virtual shop for Everquest and Everquest 2, where players can buy in-game items for dollars. In contrast, Blizzard Entertainment completely prohibits the re-selling of virtual goods or accounts, because they claim that they are the company s virtual assets. From a players perspective, both reactions have less to no influence on illegal re-selling, the higher
92 the demand for virtual treasures, the more companies will provide them. A possible solution for this is a change in the game design, as long as inequalities (different level of game achievements) in the game motivate players to pay money in order to improve their character, the sweat-shop industry will continue to gather virtual resources Technical Background for the Player Analysis The player analysis includes considerable psychological factors, although it is vital to pinpoint that the realization requires several technical aspects. These aspects will be the focus in this dissertation; because each of them will be evaluated in depth. An analysis of player behaviour is the starting point to gain a deeper understanding of next generation game design, because users define the way that games are played and therefore they are responsible for upcoming trends. Thus it is necessary to create an online questionnaire which can be reused for further studies. Also the questionnaires themselves must be designed correctly: especially with regard to a valid statistical analysis, the factors of reliability and validity are the main aspects for a good survey design. A further aspect is the multi-language support, in order to clarify the online survey as much as possible, it is necessary to support different languages for the web pages. An automated configuration with an appropriate database design is required to provide the multilingual support in general (this also includes further potential surveys). The main part for a general statistical analysis of the gathered information is the extraction of data sets from the survey. It is important to keep the data consistent and to eliminate faulty data sets. This includes both incomplete data sets as well as unrealistic answers (like age: 15 years, marital status: widowed) Operationalization Before one can technically implement a survey, it is necessary to evaluate other possible interviewing methods in order to decide whether an online survey is the best method to gather information about the users behaviour. Furthermore, an academic questionnaire needs to be reliable. Common methods to gather information about
93 users are standardized interviews, non-standardized interviews and online questionnaires. Each of the methods has its own set of advantages and disadvantages. A detailed description of the different research design, methods and structure of a survey can be found in [Kuma 2000]. Generally, one can differentiate between three academic approach techniques: exploratory research, descriptive research and causal research. In this case descriptive research will be used. In fact: The purpose of descriptive research is to provide an accurate snapshot of some aspects of the market environment (Kumar, 2000, p. 60). For the gaming scene this means, in particular, that this approach aims to point out the current players motivation. First of all, it is necessary to use an appropriate measurement method. Generally three different methods to gather users information exist: the telephone interview, the personal interview and the mail survey [Kuma 2000]. An online survey falls into the category of mail surveys. The main argument for online surveys is the expected large number of participants. Especially for statistical analysis it is absolutely essential to have a large set of answers in descriptive research. Furthermore, the close relation between the Internet as a platform for the survey and the frequent use of the Internet by the gamers also prefers this interview method. Another aspect for qualitative research is whether the online questionnaire has openend questions or closed questions. This decision depends on the goal of the survey. If detailed information about very special aspects of games is needed, then openquestions are the appropriate method. For more generalized information about player behaviour the online survey needs closed questions with a limited set of answering options. The possible sources of problems for online surveys also need to be addressed. Therefore, the questionnaire must be as accurate as possible. One needs to take the possible sources for missing reliability into account for every questionnaire. The main problems are: ambiguities, chain questions, expert questions, leading questions or the interviewer influence. The interviewer s influence can be omitted for online surveys. Ambiguities: can occur if a term has multiple meanings. Especially in a gaming content, it is important to clarify the statements before asking a question. This can be done by using examples so the user understands the exact meaning of the question. 80
94 Chain questions: are a set of questions which are closely related to each other (same topic) and guide the interviewee through the assumed answers. Therefore, they also have a strong influence, which can in turn lead to scientific inaccuracies. Expert questions: like ambiguities, the missing understanding of technical terms or unexplained words can lead to reactance and wrong answers. In order to prevent such reactions, one must explain every special term before asking the question. Leading questions: these questions give the interviewee a direct hint about the socially acknowledged or correct answer and therefore this will significantly influence the results. All of the questions in the online survey must be clear but as neutral as possible so as not to influence the user. Although the approach of understanding the players behaviour also includes reusable technical implementation, it is necessary to point out that the questions need to be designed for each survey individually. In order to decide on the dimensions of a single survey, the users available leisure time is an important aspect. It is assumed that online gamers spend a limited amount of time on scientific questionnaires, since many users are motivated to maximize their game time [Fritsch ]. Hence one should limit the overall amount of items in a single questionnaire, in this thesis the maximum number of items is set to This decision is based on the pre-survey of [Fritsch ]; the users reported that a set of 50 questions is too long whereas questions are appropriate. Furthermore, pre-standardized answers increase the likelihood of complete and wellstructured answers, and many users prefer standardized answers over open questions. Another important aspect is the design of scales for the online survey. The measurement can be differentiated into four different types of scales: nominal scales, ordinal scales, interval scales and ratio scales. Depending on the motivation, one needs to decide which scales should be used for the questions (compare to [Kumar 2000]). Both online questionnaires of this thesis use an interval scale with index numbers, since the scale with five items offers the user a limited amount of differentiation. However, the main advantage is that most users can answer correctly. Furthermore, the results can be compared statistically (each answer receives a value, average 81
95 values can be calculated, etc.). In general, the questions are designed as statements and the participants need to decide whether they agree or disagree with the statement. This technique is very similar to the Lickert scales [Kuma 2000]. Each question offers five different answers that are gathered by appling the Mean opinion score (MOS translates into Mean Opinion Score, with regard to this questionnaire it ranges from the value 1 = strongly disagree to the value 5 = strongly agree). From a scientific point of view, the MOS is usually used for descriptive research with a technical background. Compared to the scale of Lickert, which uses a score from +2, +1, 0, -1, -2 instead of 5, 4, 3, 2, 1 the difference in the analysis relies on the results. By applying the MOS, the expected median will be 3 instead of 0. One advantage of the Lickert scale compared to other single item scales (like a comparative scale or a constant sum scale) is the understandable survey design [Kuma 2000]. Multiple item scales (more dimensional questions, tables, etc.) would offer a more complex survey design; although without previous data or samples a more complex design runs a high risk of eventual errors. With the purpose of gathering underlying data for further scientific attempts, the MOS five point scale for a simple and understandable design of the online survey is used. The precise list of questions for each survey can be found in the appendix Database Architecture First of all it is necessary to decide how an online survey should be implemented. At [Dmoz] one can find a list of service suppliers for polls and surveys. Most of them use similar implementations for surveys; however, a fee is generally charged per questionnaire. Another option to implement a questionnaire is to design an appropriate database architecture and to create a system for further surveys. The main advantage of an individual database system is that once it is created, the effort to create a follow-up survey is reduced substantially. Generally, the database architecture has a cost advantage in the long run, because one does not need to pay for every survey. With more experience and multiple questionnaires one can also use the learning effects to further improve the database system, for example, by integrating a new scale for the next surveys. The downside of this design decision is the initial effort required to implement the system. Based on the fact that the research
96 field of computer games still requires considerable rudimentary information about the player behaviour, the advantages of creating an own database compensate for the initial effort. An appropriate database design is one of the main aspects for a large scaling questionnaire, thus it is important to make the database as reusable as possible. Basically, two different techniques for data collection exist: the database and the file system. The main difference between them is that the database requires an additional server which runs the storage structure. As an alternative implementation method, the file system stores the answers in a file (the internal format can be chosen accordingly) and either creates a single file or stores each of the answers separately. The major advantage of a database system is flexibility. Once data is gathered, it is still possible to view only a certain subset or rearrange the order, which would entail additional work for the file storing system. The database with its DBMS (database management system) offers the greater flexibility and reusability, which clearly promotes it as the chosen method for the surveys. The RDBMS (relational database management system) is used to design the database (most common form of database design today). Moreover, another important aspect is the independence of the web page design and the underlying database. In the user survey case, the ASP (active server pages) technique is used to generate the web interface automatically. One advantage is that these web pages are created during runtime and offer a graphical interface for the user. Not only the design, but also the language of the questions must be appropriate. Each of the users can access the web front-end from a simple browser, answer all of the questions, and results are then stored with a unique ID in the database. Due to the survey s large-scale, it is necessary to consider that an interlocking problem can occur. As soon as multiple users try to submit their results at the same time, the database needs to be writing protected for a short period in order to prevent that two results are stored with the same ID. The concrete implementation includes the usage of session IDs (on the application level) and transactions (on the database level). Basically, the technique generates a unique ID as soon as the user loads the webpage. This identification number is used to keep track of each query that a user is performing (in the case of a user survey he/she is only performing one query most of 83
97 the time, which is the submission of answers). Nevertheless, one can also perceive a survey that requires multiple pages and sub-queries during the answering process. In fact (with multiple pages) it would be possible to restore a corrupted session by using the given session ID. Hence the transaction design offers the most flexible solution and prevents deadlocks with the simple answering mechanism. Furthermore, the problem of multiple participations needs to be addressed in this context. One of the downsides of an online survey is the limited control over the user group. From a technical point of view, it is problematic to prevent a user from submitting his/her results multiple times. Possible solutions for this problem are either the usage of personalized ( address-based) accounts to participate in the vote, the usage of cookies (which are stored locally and indicate that the user has already participated) or IP-catching mechanisms (further storing of the IP to prevent a user from submitting multiple times). Besides the fact that each of the methods contains an additional programming overhead, it is also obvious that all of them can be avoided by the user as well. This aspect will be discussed in-depth in section The decision on an open participation reduces the above-mentioned programming overhead and also increases the potential number of participating users (because creating an account will significantly reduce the likelihood of a gamer participating in the survey). Nevertheless, the tremendous advantage of having a large and reliable survey prevails over the disadvantages. Figure 4.5 illustrates the ER model (entity relationship model) of the database and gives a graphical overview of the structure. Each of the four sub-tables contain one of the entities: survey, questions, answers and users. 84
98 85 Figure 4.5. Illustration of the database with ASP support, all entities are connected with a single central relation In order to clarify the assignment of entities, each of them is described in detail: Survey. This table contains the general parameters like the survey name, the caption for each survey section as well as all available languages. Each of the surveys can be identified due to a unique number. Especially for the administration of data warehousing (coordination and information seeking in huge data pools) it is necessary to select each of the survey answers specifically. Questions. This table contains the complete set of all questions that are used in the surveys. Each of the questions has its unique ID to identify them faster and connect them with the appropriate surveys. Also each question has a string with the question formulation itself. It is vital to understand that the same question in other languages will still have the same ID, which is important for data gathering after the survey is completed. Answers. The answers table contains all of the questions answer options. Due to the high amount of standardization most of the questions have similar answering patterns. The language support for this table includes a translated version of the answer for each of the languages supported (Spanish, English and German). Users. This table includes all gathered information about the user. For the two gamerelated surveys these data sets mainly contain demographic values such as age,
99 location, gender, occupation and so on. By separating user information from answers gathered, one can extend the current usage of the database. A possible usage case for upcoming online surveys would be a unique ID for each participant. This ID allows the user to participate in multiple surveys without resubmitting the demographic data each time, since it is already stored in the user table. As soon as a user submits his/her answer, a new data set is created with all of the user s answers and demographic values. Table users can therefore be regarded as the result table, which needs to be analyzed as soon as the survey has been completed. By using the central relation, each of the results can be directed toward a specific question and answer. These are stored as numbers and can be identified through their unique IDs. Especially for a statistical analysis the method of storing numbers instead of the entire answer further reduces consecutive work. The order of questions in the online survey is determined by the front-end design. The ASP pages are created just in time and contain all of the survey questions. If one wants to rearrange the order for the user, then this needs to be done in the.net framework, where the ASP pages are created. When the user submits his/her answers, interactive elements of the webpage (such as radio buttons) are read and the results contain information about the answer and the related question. Therefore swapping two questions in the ASP page would just rearrange the order of the results during submission. Since every answer is submitted with its corresponding question ID, they can still be identified explicitly. The central relation results connects each of the four tables together and ensures that as soon as the user submits the answers through the ASP front-end, the information will be stored correctly. Furthermore, each survey can be easily extended by additional questions. The expansion for a new survey, new questions or new answering mechanisms is easy, because the central relation keeps the database concept consistent Language Support and Views for the Online Survey One of the advantages of database usage is the support for multiple languages. The ASP front-end does not need to be redesigned for different languages due to the dynamic creation of the pages.
100 Each question and each answer (as long as they do not only contain numbers) already exists in multiple language versions in the database. The unique ID number for every question and answer combined with the related language identifier enables the database to automatically select the correct answer and the correct language at the same time. This is important because the setup of the pages (that the users will see when they participate) only contains dynamical elements, the headers, the questiontext, and the possible answers are merely links to the appropriate database entry. In order to ensure an adaptable method for multi-lingual support, the database system creates an index web page for each of the surveys. This page contains the rudimentary information about the questionnaire and can only be accessed by the designer of the survey. Furthermore, each of the automatically generated elements features an additional text field to enter the translated question. Instead of implementing directly in the database system, this interface allows the host of the survey to submit the translated version by completing the relevant fields. During runtime, the ASP pages created can be regarded as limited views on the database. Only the corresponding information (match in language and survey) will be displayed. By doing so, consistency of displaying order is ensured. This signifies that the surveys in different languages are completely coherent and the answering values can be obtained (language independently) from the database. This method has two main advantages: an individual page setup (language supporting) and the opportunity of a quick expansion. One should notice that as long as highly standardized questions are used in the survey (for example standard demographic values or mean opinion score answers), it is only necessary to link the new questions to already existing answers (which significantly reduces the workload). Also, questions from previous surveys can be reused by creating a new survey and adding the appropriate question IDs. By offering the index web pages, no further technical knowledge about the database design is required User selection This section covers an introduction to the problematic field of sampling, including a description of the population and different sample approaches. Each of the sample approaches is introduced with advantages and disadvantages for the problematic field
101 of computer gaming. In contrast to this background knowledge, Section describes the actual client selection for the surveys in-depth, including the age and gender distribution as well as an explanation as to which techniques have been applied. To ensure a reliable statistical analysis, the underlying population needs to be represented accordingly. Generally in statistics, a population is the entire set of elements (in our case users), which is observed. Depending on the population, it is often not possible to include the whole population in the selection. For example, Germany has more than 80 million inhabitants; a survey including (most) of them would lead to substantial costs. The typical approach to solve this problem is the selection of an appropriate sample. A sample is a representative subset of the entire population. Since the population is too large to enumerate all of the values in it, the sample can be understood as a subset with a manageable size. The selection of a fitting sample is a complex process, which can be defined as a trade-off between the effort of interviewing each subject within the sample and the aspect of creating a representative subset with only a limited number of elements. For example, the extrapolation for the next election is only representative if the sample represents the population as precisely as possible. Figure 4.6 illustrates the sampling; the sample itself should be a subset with a similar distribution. 88 Figure 4.6 Illustration of the sampling process Various techniques to create a sample exist:
102 Random sampling: This sampling method often uses larger sample sets without restrictions in participation. The subjects of the sample are chosen randomly. For example, this takes place during telephone interviews by using the telephone book or a random number generator. Depending on the exact method, the sample can be nonrepresentative because its distribution differs too considerably from the distribution of the population. For example, by taking a sample in a football stadium, it is most likely that the distribution of the sample will contain more male subjects compared to the whole population. However, the sampling decision is always closely related to the statistical question. If the survey only includes the opinion of football fans then the stadium sampling approach will most likely contain a good sample of the overall football fan population. In contrast, the approach would fail for a survey that should forecast the upcoming election. Quota sampling: In quota sampling, the population is first segmented into exclusive sub-groups. The decision as to whether or not a subject is member of the sample is based on the distribution of sub-groups in the sample. For example, the group of male subjects between 40 and 45 years of age with an income higher than EUR 40,000 in Germany is the equivalent of 1% of the population. A survey about the next election, which uses n=1000 participants and the quota sampling method therefore needs to include exactly 10 male subjects between 40 and 45 years of age with an income higher than EUR 40,000. Statistically, this method has the advantage of accurately selecting an equally distributed sample (compared to the population). The main disadvantage is the interviewer s influence, because in most cases the different subsets do not match equally during the interviewing process. This occurs because the quota sampling needs to match each sub-group precisely, which can be time-consuming for the smaller sub-groups. Therefore, the interviewer often needs to decide which subjects of the overrepresentedsub-groups need to be excluded (interviewer s influence). Cluster sampling: The cluster sampling method aims to reduce the sampling effort by creating clusters for certain areas, timeframes, etc. It is an example of a twostaged sampling approach. In the first stage, a sample area (or timeframe) is chosen, afterwards the second stage includes sampling within the selected area. For example, within the forecasting survey for the next election the country is previously divided 89
103 into election districts. Afterwards, only a small number of subjects in each of the districts are used for the sample. This method can reduce travel expenses and time invested by the interviewer (due to clustering in the first step). The general size of a sample depends on the survey s approach; [Higg 2001] provides a good introduction to the different sampling methods and the recommended size of samples. Generally, a good data collection involves: A structured and predefined sampling process For interviewer influence: note down the contextual events Keeping the data in time order (refer to Section 4.2.5) Recording and cleaning of non-responses as well as incomplete responses (refer to Section 4.2.5) This section will discuss the first two elements for a good data collection: a structured sampling process and the interviewer influence/contextual events. Before regarding the sampling methodology for the survey, it is necessary to understand the population of computer gamer. The examples regarded above differ from the population of gamers in three significant ways: a) The population of gamers is dynamic b) The sub-groups (clusters) are not selective c) A regional clustering of computer gamers is not possible The population of gamers itself is highly dynamic; the currently strong market growth reflects that even people with no previous gaming experience are becoming attracted to computer games. This growth leads to a shift in the consistency of the population. A quota sampling approach would require using a sample that represents the consistency of the population precisely. The increasing social acceptance leads to a significant shift in the consistency (i.e. more females and older people are starting to play computer games). Therefore, both clustering and quota techniques fail to represent the population exactly. Furthermore, sub-groups of game types are not selective. The prediction of results for the next election now includes selective attributes like age and income. The 90
104 objective of the distribution of the online gaming survey is to split the population up into game type sub-groups. These groups, however, are not selective as Figure 4.7 shows. In this example, a sub-group of players who prefer to play both RTS and FPS games exists. The gaming industry also promotes this trend, since fiercer competition between the game producers is leading to a more specialized game design. Hybrid games not purely classified as one of the game types are created. 91 Figure 4.7. The population of computer gamers divided into sub-groups by game type. A regional clustering of the computer gamers would also be impossible because network games provide international servers. Therefore, the local place of residence is still an important variable for the statistical analysis. However, in the case of computer gamers, it cannot provide an accurate clustering Data Cleaning Mechanisms for Online Surveys By using an open participation method for the online survey, the major disadvantage is the high potential of multiple participations by a single user. Although the target audience is as large as possible (due to no regulations like accounts, cookies, IPcatching), it is still possible to reduce the negative effects of multiple participations from a single user by creating an algorithmic solution after collecting the data. The idea of an post-algorithmic solution is the reduction of negative effects without limiting the potential answering group too much. It can be regarded as a
105 trade-off between the radical solutions of either neglecting all negative effects or creating a method to completely prevent multiple participations by means of security mechanisms. Before analyzing the procedure, one should first look at the main negative effects of multiple participations. These effects are illustrated in Table 4.2 with basic examples. Two of the three main negative effects (repeatedly submitting the same answers and submitting unrealistic combinations) can be detected by using an algorithm that compares the gathered data. 92 Table 4.2. Possible effects of multiple participations by the same user Effect Description and Result Example Repeatedly submitting the same answer multiple times Submitting unrealistic combination of answering possibilities Submitting random answers The same answer is submitted multiple times, increases the relative number compared to the rest of the data pool Creating unrealistic or fake answering combinations in order to make the correlation incorrect Randomly selected answers are submitted multiple times with no underlying scheme Consequently submitting profiles with a young age in order to lower the average age score Submitting profiles with an age of 15 years and a martial status of widowed Using an automated program or randomly clicking and submitting multiple times; creates white noise The technical implementation of the procedure works on tables. Since results in the database can be viewed as a single table with all data sets, this table can be stored for further analysis. Any spreadsheet program (like Excel) can host the table. The algorithm for the data cleaning comprises two different macros, one for each problem described (repeatedly submitting the same answers and submitting unrealistic combinations).
106 Data can be analyzed once the survey has been completed. The effect of repeated submissions of the same answer can be analyzed by comparing locally related submissions in the database. If multiple entries within a constant range (x data sets in front and x data sets after the current entry) have a high similarity (90%+ identical values), then the probability of multiple participations is high. The duplicated data sets can be eliminated by reducing the remaining data pool and clearing the negative effects. This data cleaning is implemented technically by means of a macro in Excel that compares the 50 adjacent data sets before and after the current data set (each value of two data sets is compared). If their similiarity is too high (like 95% similar answers), the duplicate is eliminated. The order of data sets equals the submission order. If a single user submits an answer multiple times within a short time period, then these submissions will be located close to each other in the table. Another problem, the submission of unrealistic combinations, can also be identified by using a simple algorithmic prevention measure. The data sets can be tested and the algorithm can decide whether or not inconsistencies occur. For instance, since the minimum age for marriage is 16 or 18 years (depending on the country), consistency of the data pool can be improved by eliminating every data set with a young age and a non-matching martial status. This part of the algorithm cannot be applied to every survey. Instead, it needs to be designed individually because the definition of an unrealistic combination depends on the set of questions. For the two surveys in this thesis, elimination focuses on the demographic data. This especially includes the removal of extremely old participations or further unrealistic combinations (like 14 years of age and divorced). Generally, the same technique can be used for the other questions as well, but for the surveys in this thesis, focus relies on a large set of answers. The stricter the method to eliminate data sets is, the more likely one eliminates correct data sets. The only problem which cannot be identified is the submission of random answers. These negative effects will remain because it is not possible to define which legal (consistent) data sets have been submitted by a user and which data sets have been created randomly. One could try to search for patterns in the data pool, however, the probability of eliminating valuable real answers increases significantly. 93
107 4.2.6 Regression Analysis as a Statistical Method 94 One aspect in the statistical analysis is the creation of an underlying model for the players. This is especially interesting for the distribution of the online player behaviour analysis because a model would indicate factors that hardcore gamers have in common. Generally, the statistical analysis for this example aims to understand how one can decide if a player can be regarded as hardcore (see Section 4.3). Furthermore, the influence of demographic factors on gaming behaviour is evaluated. Therefore, it is necessary to analyze the influence of each given independent variable. With regard to the total time invested in gaming, the related model should only include the most statistically significant variables. The regression analysis starts by testing the influence of demographic and personalized user information with regard to his/her total game time. Some factors (like occupation or gender) might have a more significant impact on the total gaming time than others. By eliminating irrelevant influencing variables, the model increases in the coefficient of determination and thus becomes statistically more significant. Finally, the remaining influencing factors indicate the characteristics of a typical hardcore gamer (regarding the example of game time analysis; however, a regression analysis can also be conducted for other problematic fields like virtual fragmentation or chatting behaviour) Hypotheses In general, a statistical hypothesis test is a method of making a statistical decision based on experimental data. A null-hypothesis testing answers the question of how well the findings fit the possibility that chance factors alone might be responsible [Cram 2004]. De facto this means: if findings for the influencing factors are significant enough, the hypothesis is rejected. For example, in a pregnancy test the hormone level is measured. Generally, the null-hypothesis is expected, which states that the subject is not pregnant. However, if the hormone level rises above a certain value x, then the high value of this influencing factor alone implies that the nullhypothesis cannot hold true. Therefore, it must be rejected based on the statistical findings. As a result the opposite turns out to be true, which means that the subject is most likely pregnant. The hypothesis tests are usually applied with a certain degree
108 of confidence, which is generally either 95% or 99%. The correct result of the example would be: with a 95% (99%) chance the null-hypothesis can be rejected, which implies that the subject is most likely pregnant. Several preparations for the observed data exist to structure the hypothesis test correctly: (1) The null-hypothesis must be stated in mathematical/statistical terms that make it possible to calculate the probability of possible samples assuming the hypothesis is correct. (2) One needs to design a test statistic that summarizes the hypothesis-relevant information in the sample (factors that influence the hypothesis). Subsequently, the distribution of the test statistic can be used to calculate the probability sets of possible values. (3) Furthermore, critical values need to be defined, effectively a confidence interval around the target value (0 in case of a null-hypothesis) is created, if the value of the test lies within this interval, then the result is not significant enough to reject the null-hypothesis Questionnaire I: Distribution of Online Player Behaviour This section features an introduction to the background of the survey distribution of online player behaviour and hypotheses are subsequently described. These hypotheses are evaluated in the experimental result section of this thesis (7.1) Background One of the main aspects addressed with regard to player behaviour is the strong influence of in-game content for real world behaviour. The most important aspect in this approach is the time each player invests in the game. Generally, the more time a player spends in the persistent online environment, the easier he/she will adopt given concepts. In order to understand how much dedication towards gaming an average player shows, one must look closely at the social deterministic. Another aspect in this study is the analysis of the heavy user ratio, the so-called hardcore gamers.
109 Hardcore is defined as being: (i) extremely explicit, (ii) intensely loyal and (iii) stubbornly resistant to change or improvement [Ency]. In the matter of gaming the term hardcore refers to option iii), being stubbornly persistent in playing the same game with far above average interest. This definition goes along with the previous usage of hardcore as heavy usage ; hardcore players tend to play much more intensively and longer than normal users. Casual playing, on the other hand, is the opposite: approaching the game with average interest (which includes lower time invested compared to the hardcore gamers). To obtain the most accurate results possible, one must look at each of the game types separately. Therefore, the survey [Frit 2006] includes the four different game types: RTS, FPS, RPG and SG each with a general and personalized set of questions. Both sets were reduced to the most important questions. Long surveys often show a lower reliability due to the overproportional decrease in user concentration. Thus the number of questions did not exceed 20. The main goal of the survey is to yield reliable results for further evaluations as well as to analyze the real behaviour of the current online gaming community. The general set of questions in the survey contains demographic information about the user such as age, gender, marital status, educational level and nationality. It also features questions about the amount of leisure time, the gaming experience and the overall game time (per week/day). This set is highly user-related and is utilized to build up correlations with game-related questions. The personalized questions, however, are more closely related to the game type. Not every game type features the same type of challenges as shown above. It contains specialized questions about in-game activities and daily scheduling, i.e. Would you call in sick from work so you can play more? Hypotheses for Distribution of Online Behaviour This section contains hypotheses for the distribution of online behaviour survey and an explanation for each of them. It is most likely that players from different game types will also have a different gaming behaviour. One of the major aspects is the average time per week that a
110 player spends on computer games. A significant difference between the different game types is expected. In order to statistically analyze this statement, a nullhypothesis is created which states the exact opposite (no difference between the game type is expected). The estimated finding is reassigned to the alternative. During the statistical analysis this null-hypothesis will be evaluated. If the initial estimation holds true (a difference exists), then the null-hypothesis can be rejected and the alternative is true. (1) H0 1 : No difference in the average game time per week between the game types exists. This initial hypothesis suggests the further evaluation of the game types. Since the age obviously influences the decision of the game types (for example MMORPGs with their monthly costs are less interesting for younger players), it might also have an impact on the overall game time. Therefore, one can suggest that demographic factors (such as age, leisure time, gender) also influence the game time. A simple correlation between these two factors would be obvious because students clearly have more leisure time compared to adults with a job. To harmonize these numbers it is important to compare the relative game time (which is total game time per day divided by the available leisure time per day). The resulting number ranges between 0 and 1, where 0 indicates that the individual spends no leisure time at all on gaming, whereas 1 indicates that 100% of the leisure time is spent on computer gaming. As is the case for hypothesis 1, the estimation is allocated to the alternative and the nullhypothesis states the contrary. (2) H0 2 : The relative gaming time (game time divided by available leisure time) is not influenced by demographic factors or the game type. Finally, the behaviour of hardcore players is very interesting. Since this group takes the games far more seriously, one can suggest that their attitude towards real life events will be similar as well. If this holds true, then the overall gaming time (not relative game time) should be proportionate to the number of positive answers regarding the player behaviour questions. The player behaviour questions each indicate a motivation to focus on the virtual world instead of the real world. If this correlation holds true, then players with a higher overall game time show a common attitude towards real world events. 97
111 (3) H0 3 : The overall gaming time (hours per week invested in gaming) is not influenced by the players attitude towards real-life events (family, real world events, job). These hypotheses are evaluated in Section 7.1 together with further experimental results; they will serve as a guideline for the experimental evaluation Questionnaire II: Virtual Fragmentation This section features an introduction to the background of the survey virtual fragmentation and subsequently, hypotheses are described. These hypotheses are evaluated in the experimental result section of this thesis (7.2) Background The complexity of social interaction between players grows proportionally with the complexity of the virtual environment. Hence, one of the important related topics is the difference between in-game and out-of-game behaviour of each player. The underlying effect of virtual fragmentation is defined as the discrepancy between real world behaviour and virtual world behaviour. The greater the difference is, the larger the virtual fragmentation. In order to measure such a difference one must look at the real world and in-game behaviour separately, and then address the reasons for potential differences or specific game behaviour adoption. One part of analyzing differences between in-game and real world behaviour is the selection of a model. Human behaviour, even in terms of gaming, can be very complex. Several models have a high degree of complexity and although they are reliable and valid, the gaming behaviour might not have been measured most accurately with them. Therefore, the five-factor model [Digm 1990] and [Ewen 1998], which is both reliable and simple enough to perfectly adjust it to gaming, was selected. The five-factor model divides the human character into five personality factors. Each of the factors defines a part of the character and thus the behaviour. Based on the model of Costa and McCrae [McCr 1996] this approach divides the personality into neuroticism, extraversion, openness to experience, agreeableness and
112 conscientiousness. Each of the factors can be considered. Together with demographic values it is possible to statistically analyze the main reasons for virtual fragmentation. Figure 4.8 illustrates the main idea of the virtual fragmentation survey with regard to the five-factor model. However, gaming communities also evolve along the games. The interaction relocates to other communication measures like forums or chats. It is difficult to take those interactions into account, although they are obviously game-related. Thus the narrower definition of gaming behaviour refers to the in-game interaction between two or more players. Computer games feature typical groups of players: the taxonomy of Bartle [Bart] divides them into achiever, explorer, socialiser and killer. Each of them shows their individual online behaviour and thus each player type has an appropriate characteristic. In order to understand the virtual fragmentation [Frit ] it is necessary to further combine the taxonomy of Bartle with the five-factor model. The approach aims to understand whether the different player types have an influence on the level of virtual fragmentation. The results of both surveys are analyzed in chapter 7. 99
113 Figure 4.8. Illustration of the idea behind the virtual fragmentation survey. The differences between real world and in-game behaviour with regard to each of the five personality factors are shown. The arrows indicate which attributes will be compared to identify a potential effect of virtual fragmentation Hypotheses for Virtual Fragmentation This section contains hypotheses for the virtual fragmentation survey and an explanation for each of them. In contrast to the hypotheses from the survey distribution of gaming behaviour, the hypotheses in this section have interdependencies. The major goal of the survey is to pinpoint the gap between real world and virtual world behaviour. Hence if no gap can be shown, a further analysis of possible influencing factors would be meaningless. The virtual fragmentation survey aims to determine a difference between the real world and the virtual world behaviour. In order to achieve this, one needs to show that the average value for virtual behaviour differs significantly from the average value for real world behaviour. Each of the behavioural traits is measured with a Lickert-type scale from 1-5, referenced as Mean Opinion Score (MOS). The statistical evaluation is analogous to the evaluation in Section 4.3.2, the estimated statement is allocated to the alternative, whereas a null-hypothesis is created stating the contrary. (4) H0 4 : No difference between the average MOS values for real world behaviour and the average MOS values for virtual behaviour exists. If this hypothesis can be rejected, a further aspect needs to be evaluated. In case of a rejection, a gap between real world and virtual behaviour exists although the influencing factors for the gap are unknown. In order to analyze possible influencing factors, a general null-hypothesis for each of them is required. It is most likely that the demographic factors (age, gender, educational level) will have a high influence on the level of virtual fragmentation. However, further aspects like the game type can be possible causes of an influence as well. To substantiate this influence, a nullhypothesis will be evaluated because if it can be rejected, then a statistically significant influence of the factor (age, gender, educational level or game type) on the level of virtual fragmentation can be shown.
114 (5) H0 5 : Further factors (such as age, gender, educational level and game type) have no significant influence on the level of virtual fragmentation (size of the gap between virtual and real world behaviour). These hypotheses are evaluated in Section 7.2 together with further experimental results; they will serve as a guideline for the experimental evaluation Methodology and Advertisement This section covers the main aspects of actual sampling for both approaches (distribution of online gaming behaviour and virtual fragmentation). The sampling section explains the user selection mechanism; the methodology section contains information about the number of participants and discusses the reliability of the samples Sampling The sampling for both approaches uses the random sampling technique for various reasons. First of all, the quota sampling method would not be appropriate for the population of the survey, because the population of computer gamers is still changing. In contrast to surveys that use data that has been available for a long time (like election predictions or price indexes) the field of computer gaming research is relatively new. Therefore underlying data (to match with) is missing. This also influences the clustering technique, because no reliable data regarding the local distribution of computer gamers exist, since most of the games do not keep track of their players real world location. Another important reason for making use of the random sampling method is the effort vs. benefit. The selection of individual users for the sample is comparably lowcost in the random sampling method, because especially with larger sample sizes (n=1000+), the quota and cluster sampling approach both require a large preparation effort. To illustrate this disadvantage: the quota sampling would require an exact representation of the population in the sample. To ensure this, standardized offline interviews would be needed (because the interviewer needs to ensure the matching of factors like age, education and gender).
115 A large sample is also more resistant against typical problems of Internet surveys. A single user can therefore not influence the outcome of the survey (due to multiple participation or submission of random numbers) as much as he/she could in a smaller survey. Furthermore, the probability of creating a representative sample without bias due to random sampling increases with the number of participants. The chance of having a biased sample increases with a decreasing number of participants. For example, a sample size of 25 users can be biased because 10 of the users are friends with similar gaming behaviour. The Internet survey method also promotes the random sampling method, since one of the major aspects in the creation of the surveys was the size of the sample. Both surveys aim to receive as many answers as possible. With an overall number of more than 30,000 users (in both surveys together) the sample achieved the goal of having a very large data set to work with. Typically, a different sample size leads to a different accuracy in measurement. Generally with all else being equal, a larger sample size n will lead to an increase in accurate estimates of various properties of the population. As a rule of the thumb, a sample size of n=100 already provides reliable results. Compared to an overall sample size of 7,100 cleaned data sets for the survey distribution of online gaming behaviour and 5,800 cleaned data sets for the survey virtual fragmentation, the underlying samples provide an excellent example of the gamers population. The rule of the large number underscores that the higher the sample size, the more likely that the population will be represented accurately. Furthermore, the statistical central limit theorem states that the sum of a large number of independent and identically distributed random variables is approximately normally distributed (which is the case in both surveys because the participating users neither have an influence on each other nor do they vary in their distribution). To ensure this distribution, the Jaque-Bera test was used on both the original sample and the cleaned sample; both samples were distributed normally. The target group for the evaluation in both surveys (virtual fragmentation and distribution of online game behaviour) is the community of online players who play competitive online games on either PCs or consoles. This population is the focus of the survey evaluation for two reasons. 102
116 First of all, the overall Internet gaming community also features a wide variety of minor games, such as browser games, text games or freeware. Since those players show a very distinct gaming behaviour, the focus for this thesis relies on current topselling online game genres, which are RTS, RPG, FPS and SG. Afterwards, findings are compared to other surveys like the casual player evaluation in [Case 2007]. The remaining sub-sections (like casual players) also have a significant market share, however, the amount of casual games exceeds the commercial games from game genres observed in this thesis by far. Their production effort, their average game time and their graphics are lower/less detailed compared to the top-selling online games. The second important aspect is the interaction within these games. The remaining game types like Beat-em-up, Puzzles, Edutainment, Casual games and asynchronous games seldom feature any player interaction besides the game content. This signifies no predominant chatting or in-game voice. Some of them are mostly single player oriented. Thus effects like virtual fragmentation will most likely not occur, because the players have little to no interaction options besides the game content. A detailed comparison of the demographic factors between the surveys in [Thee 2007], [Casu 2006] and [Fritsch 2007] is featured in Section Methodology The approach to reach a large sample size included general decisions for both surveys: The survey method chosen is the online questionnaire The distribution of game time survey aims to understand influencing factors for a high computer gaming time. Furthermore, it should provide general data about the overall game time of current online players The virtual fragmentation surveys aims to pinpoint differences between real world behaviour (modelled with the five factor model) and virtual behaviour. Also the influencing factors of demographic factors need to be analyzed Demographic factors for both surveys are age, gender, location, leisure time and education/employment Analyzed game types for the surveys are FPS, RTS, RPG and SG
117 As discussed above, the online questionnaire and the decision to receive as many answers as possible only work well with the random sampling method. In the first phase, the ASP webpage was prepared as well as a standardized advertising text. In order to ensure an international character of the survey, the advertising text was translated into German, English, French and Spain and used in accordance with the local forums. Afterwards, target forums were selected: as a guideline the forums of the top 10 selling games of FPS, RTS, RPG and SG as well as the relevant inofficial fan sites are used. For a closer relation with the player community, many community forums (clan, guild, and server) were selected. In addition, general game-related community sides were selected, which provide a player base for a certain genre. These can be regarded as accumulations of players with a preference for one of the game types. Forums were selected carefully, because distribution can influence the distribution of the sample. However, the overall number of forums selected was over 250, again this decision clearly promotes the motivation for a very large sample size (and thus reliable data). In contrast to the surveys of [Park 2006] and [Casu 2007], the evaluation of the online surveys in this thesis does not focus on the entire population of all players in all genres. As indicated in [Park 2006], the US gaming market is segmented. A relatively large amount of players from this survey are occasional gamers or hobby gamers. These players, however, are explicitly not the target group of online surveys in this thesis because in most cases they do not play FPS, RTS, RPG or SGs. As [Casu 2007] indicates, the population of casual gamers shows an intercommunity regarding demographic factors and the players motivation to frequently change their games. The overall time invested in games, the background knowledge and the understanding of game mechanisms is relatively low, the main focus of this group of players is pure entertainment. As part of the analysis, demographic data was compared between online gamers and casual gamers. In phase two, the advertisement was posted on the more than 250 different gaming forums in one night, so the starting date for each forum was practically identical. The data collection period was two weeks (14 days), in order to also receive information from players who do not visit the forum on a daily base. 104
118 The rate of return shows a different behaviour between the top-selling game pages and online communities. Generally, the rate of participants from the online community is far higher compared to the top-selling games. One recognizable exception to this trend exists, a majority of nearly 7,000 answers overall is based on the World of Warcraft forum. A large amount of players from that forum demonstrate interest in the survey. This fact is one substantiation for the high amount of RPG players who answered the questionnaire. For the distribution of online game behaviour survey:, about 1,300 users from the FPS sector, 1,100 RTS users and only 197 SG players (compare to Table 4.3). The distribution of online gaming behaviour questionnaires contained 20 questions; the virtual fragmentation questionnaire contained 38 questions (the higher number of questions was necessary to provide enough individual questions for each of the five factors). Table 4.3 gives an overview of the number of participants in each of the surveys as well as the number of remaining cleaned data sets. Both surveys had a similar number of participants before the data cleaning. The number of remaining data sets is smaller for virtual fragmentation. One reason for that is the higher number of questions, only complete answers were included in the cleaned data set. 105 Table 4.3. Overview of the number of participants and the number of cleaned data sets in both surveys Survey Number of data sets Number of cleaned data sets Distribution of online gaming behaviour FPS 18.0% 1297 FPS 18.3% 2525 RTS 15.7% 1101 RTS 15.5% RPG 63.5% 4501 RPG 63.4% 452 SG 2.8% 197 SG 2.8% Virtual FPS 21.1% FPS 22.3%
119 Fragmentation RTS 13.7% 817 RTS 14.1% 8673 RPG 61.2% 3501 RPG 60.4% 567 SG 4.0% 185 SG 3.2% Distribution in Table 4.3 shows one of the disadvantages of the technique of online surveys. Although the sport games section was equally activated with a similar number of forums (game-related and top 10 selling game forums), the reply rate is significantly lower compared to the average response rate. In contrast to that, the rate of return is very high for the RPG sector. An analysis of the different forums substantiates possible influencing factors; the average number of new posts per day is lower in the sport games forum and much higher in the RPG forums. This means that the players general activity from the genre is much higher/lower compared to others. For example: the RPG forums are very active, making it more likely that players see and respond to the advertisement. In order to prevent this unequal rate of return for future surveys, it is necessary to harmonize the findings. A harmonization factor therefore needs to be created based on the number of overall players in the genre. With such a factor the overall influence of bigger sub-groups would be reduced, whereas influence for small subgroups (such as the SG sector) would be larger. Another option is to pre-select participants. The approach in this thesis contains active sampling, which means that participants are contacted for the first time. One disadvantage of this method is that the participants answering are most likely extremely interested/involved in the topic. Passive sampling on the other hand indicates that users participate in the survey who have already participated in previous surveys. Usually they reveal a more indifferent behaviour to specific questions, whereas their overall involvement is high. According to [ADM 2001] a mixture of active and passive sampling generally leads to the best sample. Therefore for future surveys, the database will be used to store the participants addresses pending their consent. In order to ensure that the cleaning algorithm does not significantly change the distribution of the sample, the following aspects were compared between the original data sets and the cleaned data sets: (a) distribution of age, gender, leisure time, (b)
120 quantity of game type subsets (FPS, RTS, RPG, SG) and (c) normal distribution. This analysis underpinned that the cleaning neither changed the demographic values nor the relative quantity of game types. Both samples were also distributed normally. The gender distribution of data collected is similar to other online gaming surveys. A large majority of participants are male. Table 4.4 gives an overview of the rate of males in the sub-groups. As one can see, the gender distribution is not significantly influenced by the data cleaning algorithm. Overall, both surveys have a large majority of over 90% (95% for online gaming behaviour) male subjects within the sample. The different game types have a minor influence on gender distribution; female players tend to prefer RPG games over FPS and RTS games. The values in Table 4.4 are percentage values of the target sub-group (percent of male players compared to the overall population of the sub-group). 107 Table 4.4. Gender distribution in the online surveys Survey Male rate before cleanup Male rate after cleanup Overall 95.8% Overall 96.0% Distribution of online gaming behaviour FPS 97.9% FPS 97.8% RTS 98.9% RTS 99.2% RPG 92.3% RPG 92.3% SG 94.5% SG 95.3% Overall 91.2% Overall 91.0% Virtual Fragmentation FPS 93.1% FPS 92.7% RTS 95.9% RTS 96.4% RPG 89.9% RPG 90.1% SG 89.5% SG 89.6% Another interesting aspect is the influence of the survey language. The advertising strategy included forum entries in all of the featured languages: Spanish, English, French and German. The majority of replies in both surveys were in English. Overall 60.2% of the data sets were originally collected in English, 25.5% in German, 7.8%
121 in French and 6.5% in Spanish. None of the languages has shown a significant influence on the demographic values of the surveys (age, gender, educational level) Summary Both social factors, the importance of player behaviour as a main influence for the game design and the acceptance of gaming in the culture, have a significant importance for the approaches. Without understanding the player s motivation, one cannot efficiently improve current gaming problems. Hence this chapter introduced different ways to define game challenges for a player to help analyze the motivation for strong game addiction. Afterwards, general guidelines for the design of surveys are included, which help to make the online questionnaire reliable. Furthermore, two main approaches have been introduced to measure the distribution of online player behaviour and the difference between in-game and real world player characteristics. The results of both approaches are discussed in chapter 7. As a side note, one should keep in mind that the technical details for a database setup and a semi-automated data selection are implemented in order to reuse these methods for further surveys. Especially with regard to the scalability and performance of the game-related surveys, the database approach introduced promotes further largescaling online questionnaires.
122 Approach II: Next Generation Mobile Gaming Home computers are being called upon to perform new functions, including the consumption of the homework formally eaten by the dog, Doug Larson. The emphasis of this chapter relies on the gaming aspect of mobility. Hence it contains a brief introduction to the motivation of the mobile gaming field as well as a short summary of the important network aspects. The technical details include two main aspects: the usage of J2ME technology for standardization and the integration of instant messenger communication in a mobile environment. Afterwards two approaches towards an innovative gaming concept are described in detail. The first includes a general improvement of player communication and the second features the design of a mobile lobby platform. Furthermore, the importance of communication in the mobile environment is underscored by a survey. 5.1 Motivation and Overview The mobile game scenario presents its own set of problems for real-time applications. State-of-the-art today is that GPRS and UMTS would provide a stable connection to a server, supporting login functions and cheating protection. The natures of the 3rd generation protocols (cdma2000/umts) clearly promote a S/C over a P2P structure. However, depending on the country, prices for a MB of data on mobile devices vary up to 10 dollars. Thus most of the end users cannot afford to play under those pricing circumstances. The other option is to create local subnets with WLAN or Bluetooth. Although possibilities exist to promote one of the nodes to be a local server and create small server-client architectures, experience shows that the risk of a network split and the disadvantage of having a single bottleneck obviously do not promote this solution. Instead, pure P2P or hybrid systems offer the advantage of having a flexible data distribution and a stable network. The lack of cheating protection appears to be the greatest disadvantage.
123 In order to create a mobile solution that fits multiple games and combines next generation technology with the needs of a gaming community, one must keep several aspects in mind: the current network structure certainly has its limitations when it comes to latency-sensitive applications like FPS or RTS. Hence the design must use techniques like WLAN or Bluetooth to support these game types. Another important aspect is the constantly growing number of simultaneous users of these applications, especially with a focus on current evolution in mobile MMOGs Mobile Communication for Games One of the most important aspects in the mobile game design is the usage of communication. One must differentiate between handheld devices and their capabilities; the mobile gaming market has a wide variety of different handhelds. Older devices (like the Game-Boy) only support fixed link connections to other handhelds, which require additional cables. Newer game oriented devices (like the Nintendo DS or Sony PSP) use WLAN as the wireless communication method. Mobile phones on the other hand are based on UTMS/3G network technology in order to communicate with others. From a gaming perspective, this network can also be used for gaming applications, although disadvantages like high latency occur. Before developing an application for the mobile sector one must look at the current communication between players within the Internet. Besides pure in-game chatting, a large part of communication is done by instant messengers. These applications do not only offer the pure service of exchanging messages over a network. In general, they allow the user to communicate with others in real-time by using a form of text-based messages. This communication can also include the transfer of data files. The clear contrast to the classical communication relies on the fact that the messages are being sent and received at the same time (besides delay, network loss, etc). Another important aspect of instant messengers is the option to register other users as buddies and build a list of friends. Each contact has its own chat history and status. Therefore, the user can see who is online and available and even (depending on the protocol) leave messages for offline contacts. Current clients are even capable of
124 transferring files with peer-to-peer sharing; furthermore, audio and video chat options are also available. 111 Figure 5.1. Current AOL IM version: Left window shows the buddy list, right window is the ongoing instant message chat Admittedly not all of the features mentioned are necessary to improve the chat situation in games. A voice and video communication would increase the options in a player group and even give them an advantage for the game content. Although such a feature should be optional for now, not every player has a microphone. As an example, the current gaming oriented devices (Nintendo DS and Sony PSP) do not have any support for voice communication yet. On the other hand, mobile phones have the necessary hardware, but the bandwidth of a multi-user video chat can easily exceed the capacity of a current UMTS connection. Moreover, displays of most nextgeneration handhelds lack the size to depict an additional video window (this problem remains for every current mobile handheld, since most of the displays do not exceed 400x300 pixels).
125 112 Figure 5.2. Illustration of the current chat situation in MMOGs While playing online games, a single user has several options to communicate with others. Generally, they are divided into in-game and out-of-game chats. While the in-game chat uses protocols of the game itself, the player is limited to communicate only with other players who are currently playing the same game. The out-of-game communication (like instant messengers) relies on different protocols, depending on the messenger used. The player s motivation to communicate with others while playing the game strictly depends on the content and speed of the game. A fast-paced game setup like an FPS death-match in Quake leaves less to no room for further chats. In contrast, many other MMORPGs feature a wide online world that also requires traveling. During this time many players want to communicate with others. This need also includes out-of-game communication, which cannot be done by the in-game protocol itself. Therefore, players frequently have an additional IM client (third party software) running in order to communicate with other out-of-game contacts. As one can see in Figure 5.2, the current problem relies on the fact that players cannot chat with in-game friends when they are not running the game client (except if they have added them separately to their /im buddy list). Furthermore, while playing in full-screen mode, offline real-life friends and those who are not playing the game simultaneously are not available either. The general idea is to merge both in-game and out-of-game contact lists in order to give the player the opportunity to be connected in the most flexible way when playing even while using only his/her
126 instant messenger. By integrating features of the instant messenger into current (mobile) games, the game chat would be expanded substantially (further details in section 5.3). Before taking a closer look at the possibilities to merge both technologies, one must first consider the underlying online games and their communication features. The significant difference between Internet MMOGs and mobile MMOGs is the performance of the network technologies. Today, there are already several solutions for persistent online environments on the Internet, however, the mobile gaming scene still lacks those solutions. Existing mobile MMORPGs do not really offer a persistent online world, because by using GRPS and UMTS as the protocols, the resulting network latency completely prohibits any real-time game elements [Fant], [AOF]. Since a mobile MMOG is still not available to integrate the instant messengers, the target MMOG must be taken from the Internet sector. This is how a cooperation (between the Freie Universität Berlin and CCP Gaming) was forged with Eve Online; main focus of the integration relies on the aspect of scalability. Eve Online is a so-called second generation UMMORPG. Moreover, the game itself reveals similarities to the traditional MMORPGs, nevertheless, there are important differences. As an UMMORPG, the game itself does not feature different shards and therefore does not split the game world up into several realms running in parallel. The result is a single realm with up to 25,000 users playing simultaneously. Consequently, the chat volume exceeds the already high number of other MMORPGs by far, which further suitably addresses the scalability problem. The in-game client offers separate individual group, clan, and private channels as well as public OOC (out of character) and trade channels. Just like in other second generation MMORPGs, one can have a list of in-game buddies to directly communicate with (private chat). The buddy list does not include real-life contacts and it also does not offer the opportunity to leave a message for an offline player Analysis of the User Group for Mobile Applications In order to contribute a new approach to the mobile gaming situation, one must first evaluate the current problems by analyzing the players specific needs. The study on mobile gaming refers to the basic user survey of [Frit ], which shows an ASP
127 online questionnaire with a set of 20 questions. The questionnaire underscored current mobile gaming preferences: a quick and easy game setup, an average game time of less than 15 minutes and high player fluctuation. The main findings are summarized as follows: - The typical user group of mobile phone games is a young peer group from in the year age bracket with a high interest in games, high expectations and a low budget. - There is a clear correlation between age and game time as well as age and interest in games. Generally, younger people show an affinity to computer games. - The average usage time of mobile phone games is much less than 15 consecutive minutes. Longer game sessions are rare exceptions. - A correlation between age and game time spent on mobile phone games could not be ascertained. These findings influence both of the given research approaches in this section. On the one hand, insights into user behaviour are used to create the mobile gaming lobby. This attempt results in the fact that a majority of users prefers a fast game setup and the average game sessions do not exceed 15 minutes in most cases. The gaming lobby and its implementation are described in detail in section 5.3. On the other hand, the aspect of communication in a mobile environment also has an influence. In fact, most of the players rate the current mobile games as rather unattractive due to the poor quality of graphics and the strictly limited game play. One option to design a gaming-related application for mobile devices is the usage of instant messengers [Frit ]. With these messengers, players can stay in contact with in-game friends from PC games without the need to run the game client. Therefore, the second approach aims to integrate current instant messenger technologies into persistent online environments. Furthermore, integration should allow mobile devices to run a chat client that enables communication with in-game friends from the PC games. 114
128 115 Figure 5.3. An overview of the complete survey, including database & J2ME relation Figure 5.3 shows an overview of the mobile phone gaming research approach. In the first part, a short survey with the 20 most important mobile gaming-related questions was designed. Furthermore, the effect of input limitations on game performance was evaluated by using two test groups of players. The testbed required that one of the groups plays the given games on mobile phones, whereas the other group uses an emulator for mobile phones and a standard PC with a monitor display. The purpose of the emulator is to integrate the same mobile phone games on a standard PC. This enables the player to use a keyboard for the controls. Each of the groups consists of six players who had to play the three different test games (from the RTS, FPS and arcade genre). By giving the players a fixed task, the required time was measured and compared afterwards. In order to make the findings more reliable, each game was played multiple (three) times. As a main finding from the first part of the survey, it was observable [Frit ] that the players with regular cell phones were significantly slower compared to the players who used emulators. The second part of the approach is based on results from the first half (including the findings about game performance and the online survey). Hence, a follow-up survey integrates more technically related questions about the gaming behavior, especially player performance and preferences for game setup. Furthermore, the approach
129 includes the design of a mobile gaming tool, which is described in-depth later in this section. By analyzing the mobile players behaviour in the follow-up survey from Figure 5.3, the aim was to understand how the preferences are split up between different countries of Europe. The follow-up survey is based on results of its predecessor [Frit ]. Hence, the set of questions is reduced as much as possible to obtain a high number of answers and thus reliable results. The survey uses the database system from Figure 4.5: all questions were translated into German, English, French and Spanish. Moreover, the results are the source for the both research approaches in Figure 5.3. Table 5.1 illustrates the main questions of the follow-up survey. Table 5.1. Main questions of the follow-up survey in mobile gaming 116 Question Would you like to play multiplayer mobile phone games with your friends? Would you also play these games with random participants? How important is a fast game setup with mobile phones for you? Would you pay to play mobile phone games? Which game type do you prefer on mobile phones? Answer options (yes/no) (yes/no) (MOS: 1 to 5) (yes/ no) (FPS, RTS, Puzzle, Arcade, Action) Do you take mobile phone games seriously? (MOS: 1 to 5) Would you also play mobile phone games if you had a next generation handheld like Sony PSP or Nintendo DS? (yes/no) How do you like the graphics on Nintendo DS and Sony PSP? (MOS: 1 to 5) How do you like the graphics for games on current mobile phones? On average, how long would you play games with multiplayer support for mobile phones? (MOS: 1 to 5) (Minutes)
130 One main aspect is: How much impact does playing mobile games with friends/strangers have? And if there is a significant impact, how can that affect game design? Due to the results from the predecessor in [Frit ] a very short game time on average is already estimated; combined with explicit knowledge about the game preferences towards friends and strangers in mobile gaming. This will help to clarify the situation further. Overall, 1,123 people participated, and thereof 1,080 participants answered all ten questions. The questionnaire moreover included a small demographic part (location, gender, age) to statistically analyze correlations with those values. The results underpin important aspects of the current mobile phone gaming situation: Data gathered indicated that a majority of over 90% would like to play mobile phone games with their friends, whereas only 42% (36% women, 45% men) would consider playing the same games with random people (see Figure 5.4). Women tend to prefer not playing those games with strangers even more than men. These figures indicated that most users enjoy playing the games with friends. Especially when traveling with friends, a mobile game offers the opportunity to experience something together. For this purpose an in-game network setup is adequate, because the users probably have one particular game in common and can start a multiplayer session with it. The other aspect of the results is that around 40% of the users are willing to play a randomly matched multiplayer game in a mobile context. Firstly, this means that more than 50% of the users prefer rather not to play instead of being matched with unknown people. However, the remaining 42% indicate that there is demand for random matching; the typical game situation for a random matching could be a bus or an underground train. An example: travelers on the train want to spend their time on a fast game setup with other gamers. One can assume that it is difficult to find a common game since the players do not know each other. Without knowing which potential games all other players have installed on their devices, it is not possible to create a multiplayer session quickly. Further results of the survey also indicate that other important aspects of the game design (such as content, graphical performance and game setup) do not meet up to the users expectations. 117
131 118 Figure 5.4. Male and female opinion on playing mobile phone games with friends / random people Figure 5.4 shows the differences in player preferences for mobile gaming. It turns out that a majority of players prefers to play with friends instead of with random opponents. A deeper statistical analysis of the survey questions as well as the main findings from the lobby design can be found in [Frit ]. 5.2 The Factor Mobility and its Technical Aspects The aspect of mobile gaming offers various technical effects to solve the trade-off between wireless connections on the one hand and strict network condition requirements from the games on the other hand. Several important factors for the mobile gaming research approach in this thesis will be described in-depth in the following section. Thus it is important to clarify the main problems of mobile gaming in order to decide whether or not they can be improved. This especially includes focus on a certain subset of problems, because it is not possible to completely solve the trade-off between resource-constrained devices (mobile gaming handhelds) and high user expectations (game requirements). Afterwards, one should analyze the different mobile devices in order to point out their individual advantages. On par with that, especially for the mobile phone
132 section, it is necessary to identify a common standard to develop applications (due to the large number of different cellular phone types). The J2ME SDK (Java 2 Micro Edition) aims to create such a standard and support a majority of all next generation mobile phones. Based on the given J2ME standard, the technical details of the lobby tool (from the second part of the mobile gaming research approach) need to be analyzed in detail. In particular, the creation of generic interfaces for new mobile games needs to be addressed. Moreover, another aspect is the integration of game-related functionalities into a mobile environment. Therefore, the technical details of next generation in-game communication must be observed. Main focus will still be on the usage of instant messengers as additional communication platforms while playing online games. Based on the relevance of these messengers and their frequent usage, a technical solution to adopt the chatting mechanism for persistent online worlds is described in detail. The result is an implementation design of generic software integration for every instant messenger; the provided interfaces offer any MMOG the opportunity to integrate the messenger into their game engine and to thus merge two existing technologies in order to improve the quality of communication Problematic Field: Mobile Gaming The scientific research field of computer gaming in a mobile context offers a wide variety of problems. For example, the server-client model for the network infrastructure cannot simply be applied to mobile networks. In order to introduce the most common game-related problems, Table 5.2 gives an overview of the four main categories and a short description of the effects and results. Further problems exist, although due to the highly specialized mobile sector applications, these problems only partially affect the computer games.
133 120 Table 5.2. Illustration of the relevant problems in mobile game design Problem Description Result Missing Common Standard Resource- Constrained Devices Input Limitation Protocol Structure Huge variety of different handhelds (mobile phones, PDA, gaming handhelds), no common game design standard for game interfaces, technology and network interfaces. High game requirements based on games from the PC and consoles, adoption of known game mechanics. Players are influenced by the graphical standard from PC and console games. Strictly limited input options, missing mouse/joystick, cellular input structure for mobile phones (depending on the mobile phones usually ITU-T keypads are used for dialling) Available options: WLAN/Bluetooth or GSM/UMTS, high latency, instable network status, possible packet loss Individualization, adoption of successful game mechanisms (game cloning), missing compatibility because of incompatible network interfaces. High expectations of players conflict with the limited graphical performance of the mobile devices. Further game specialization, no common input standard, especially for mobile phones different key bindings exist, strictly reduced interactivity. Influence of the game mechanics, in-game inconsistencies, reduced interactivity. Missing Common Standard. One of the major problematic fields is the missing standard for computer games in the mobile environment. Mobile handhelds (cellular phones, PDAs, gaming handhelds) have their own individual technical standards which creates a compatibility problem. One negative example is the design of quake 3 mobile, which was the mobile game of the year in Although it has a superior design, the game itself only supports a very limited number of devices (Samsung Nexus and LG VX360).
134 This effect is even more drastic for the next generation game handhelds (like Sony PSP and Nintendo DS). The game structure clearly prohibits adopting a game from another gaming platform. But both of the mobile gaming approaches in this thesis will mainly focus on the technical aspect of missing common standards and they aim to close the current gap between the mobile devices. Technical details will be discussed in the following sections. Resource-Constrained Devices. The technical configuration of mobile devices has witnessed significant change over the last five years. Especially mobile phones have been further developed and are now capable of distributing enough resources for simple gaming applications. Although one can still observe a major difference between gaming oriented handhelds and mobile phones, the hardware s general performance has increased significantly. A trend towards touch screens can also be observed: the most popular example is the I-Phone because the device offers a single touch screen for most of the functionalities. Newer models from Sony Ericsson and other retailers also feature touch screens, and therefore one can expect that the input technology of mobile devices will change within the next five years (towards including more touch screens and larger displays). However, resource-constrained devices still pose a problem that will remain consistent over time because the evolution of mobile handhelds will always be compared to the alternative solutions (PC or consoles). It is unlikely (due to the release of the Playstation 3 and the continually enhanced performance of PCs) that the current trend in fixed platform evolution for gaming has come to an end yet. Input Limitation. The effect of input limitation (due to the limited space) is still one of the most significant disadvantages of mobile devices. Especially the current generation of mobile phones only provides a very limited cellular structure (usually ITU-T keypad, which is also used for dialling), which reduces the game performance noticeably [Lazz 2006]. The solution for such limitations can either be a software-based approach (finding a common standard for mobile phones to integrate further button options) or the design of more intelligent hardware solutions. One should also notice that the trend towards touch screen displays for a smoother input can be observed for any of the mobile 121
135 devices (PDAs already have a touch screen, the Nintendo DS has an additional touch screen input and even mobile phones like the Apple I-Phone or the Samsung Nexus integrate them). Protocol Structure. The current network structure (as described in Section 2.2) features the trade-off between the available solutions. Currently, both opportunities (UTMS and GSM) offer insufficient game support for various reasons. Nevertheless, the development of current mobile games aims to integrate WLAN and Bluetooth for most of the multiplayer games because these techniques do not require additional communication with a central server Mobile Devices and Java Micro Edition One major aspect in the mobile gaming environment is the lack of standardization of the devices. As an example: most of the games from [Jamb] support a very limited list of mobile phones (generally between two and 20 different models). Also gaming oriented handhelds (like the Nintendo DS and Sony PSP) strictly limit their games so they cannot be played on other devices. In the case of mobile phones, missing standardization can be attempted with a software solution. J2ME is required to create a common standard for applications on mobile devices. The J2ME (Java Platform 2, Micro Edition) integrates the programming language Java for embedded consumer products such as mobile phones and PDAs. It aims to integrate a basic set of features. So-called profiles offer an API for the devices. The profiles for mobile phones are called Mobile Information Device Profile (MIDP) and applications that use the functionality of the profiles are called MIDlet. The idea behind the MIDP is to standardize input functionalities and displays of mobile phones. Especially games for mobile phones frequently use J2ME because it offers the opportunity to run the game application on more devices. Gaming applications often use special functions (mostly relatively graphical intensive, fast-paced commands). The design of mobile phones has changed significantly; the iphone [IPho] already integrates a large touch screen as the next generation of mobile phone inputs. As soon as this technology becomes more important for other mobile phones, members of the JCP (Java Community Process) can submit a proposal to expand the J2ME library. This process is one of the major
136 advantages of the J2ME platform because newer technological features will be integrated. As soon as these functions are supported, every game MIDlet can use them Academic Approach: Lobby Tool In this approach the J2ME platform is used for the design of a game-related application: the mobile lobby. This approach abstracts from the pure creation of new game applications. Players preferences indicate that an easy game setup and a short overall game time are significant influencing factors (refer to [Frit ] for a deeper analysis of players preferences for mobile games). One method to reduce the game setup time and to increase the chance to connect to other players also improves the usability of all mobile phone games. Unfortunately, the current mobile phone design offers a personalized matching mechanism for every multiplayer game. Once the gaming application starts, one can look for potential opponents (who also need to have a running version of the game), in order to set up a multiplayer session. It is not possible to find players with other games. Due to the very limited time in most mobile environments, the probability of finding a potential opponent is relatively low. With a constantly increasing number of new game releases, the chances for two players to start the same mobile phone game decreases even more. A general solution for this problem is the creation of a lobby system (based on J2ME), which supports the majority of current mobile phones games. The lobby itself needs to be designed as a chatting environment, where all users have their own profile. In general, the lobby tool is game-independent, which means that every other user in range can be found. As soon as more than one person is in the chat mode, one can look for a common game. The profile of each player contains the names of installed game applications on his/her device. Therefore, other players receive information about which games a user can theoretically play. This knowledge further speeds up the organization of game sessions. A faster game setup can be realized by creating interfaces to each of the installed games, so players can meet at the lobby and directly access the games on their mobile devices. A technique like this would make it necessary for the game design to
137 integrate the appropriate interfaces into the games. Without support of the games, it is only possible to start the target gaming application, but afterwards it would require a manual multiplayer setup. By using the J2ME SDK as the underlying technology, it is also possible to integrate further devices (like PDAs) that are capable of running a Java virtual machine. The common standards for the mobile phone sector might not be applicable for other mobile handhelds (this strictly depends on the goodwill of the mobile phone manufacturers and the development of further PDA support) Problematic Field: Instant Messenger Besides the aspect of player matching in a mobile environment, there are also other ways to improve the current game situation. One possible option is the creation of game-related applications for the users. Currently, mobile devices do not offer the necessary hardware to compete with personal computers. Furthermore, both consoles and personal computers are being redesigned continuously to further improve the hardware s performance. Over the long run, mobile devices (due to their size) will always offer less performance compared to stationary systems (like the personal computer or a console). As long as newly released games have high system requirements, which can only be matched by the personal computers, mobile device games will be less attractive. Currently, most users complain about the poor graphics within the games [Fritsch ]. Therefore, alternative methods need to be developed to support mobile gaming. One method to support gaming in a mobile environment is the integration of mobile devices into current MMOGs. The aspect of player communication plays an important role: many players want to stay in touch with friends who also play online. The mobile devices constrained resources prevent them from running the game engine, which is needed to chat with others. By integrating a method to run the pure chat environment on mobile devices, a user can stay in touch with in-game friends even when travelling. The game itself cannot be played in a mobile mode due to the missing hardware requirements. However, the chat itself does not require a high performance; therefore a text interface for mobile devices can be designed.
138 Since the hardware limitation is not the only problem for mobile devices, another relevant aspect is the limited input structure, which also affects the general game play [Fritsch ]. Besides the obvious problems of controlling a fast-paced game with such limited input possibilities, a further in-game communication would expand the users possibilities. It is therefore necessary to broaden the common term of mobile gaming from a participating perspective to a more generalized view, which also includes gamerelated activities. In the fixed multiplayer environment, instant messengers have become an important alternative communication method. Especially in persistent online environments (MMOGs) players tend to use additional communication software in order to stay in touch with non-playing friends. The protocol structure of instant messengers relies on messages (depending on the publisher). Generally, ICQ/AIM uses the OSCAR protocol (Open Service for Communication in Real-Time), whereas the MSN (Microsoft Messenger) uses its own protocol. These protocols are not compatible, although multi-protocol applications exist (which use sniffing methods to create appropriate commands). The instant messengers offer a way to integrate user communication into games and they also provide constrained-resource devices (like PDAs and mobile phones) with the opportunity to run the applications. By using them, one can connect a mobile device player with a stationary system. Two main interfaces need to be designed: one interface (GUI) for the mobile devices, which allows the user to chat while being mobile. The second interface is the integration of instant messengers into gaming applications, so players on stationary systems can use the in-game chat to communicate with their friends who are travelling Academic Approach: Generic IM Integration In order to integrate game-related activities in a mobile environment, players would need to demonstrate clear interest in using applications that are specifically related to gaming (like instant messengers to communicate with fellow players) but without a real game content themselves. Mobile devices do not offer the necessary hardware support to run a client of a next generation MMOG, as mentioned above. Hence, ingame chatting mechanisms (in-game channels) of commercial fixed network
139 MMOGs are also not available, which leads to the fact that the user cannot communicate with in-game contacts in a mobile environment. In order to create an independent solution for all MMOGs, it is necessary to integrate a popular communication method (like instant messengers) into all of the current games and to thus create a common solution. With the TOC (Talk to OSCAR) protocol, the basic functionalities of ICQ and AIM can be used without the need to run the original graphical interface of the instant messenger client. Therefore, a generic implementation (a software middleware approach) enables these functionalities to be contributed to every MMOG by creating general interfaces. As a result, publishers can implement the graphical front-end of the instant messenger themselves and rely on the given communication interfaces. As an example, it is possible to use the TOC gateway server to embed the rudimentary functionality of AIM and ICQ into a current MMOG (this thesis focuses on the exemplary implementation for Eve Online [EveO]). The commands available with the parameters required from the TOC server are included in the software application and generic interfaces and they offer simple commands like send <string>. Due to the generic nature, it is generally possible to integrate every common instant messenger into different MMOGs by using the same interface method. Accordingly, a player could see all of his/her online buddies, even those from different games, in a merged friends list. The advantage of integrating instant messengers in a MMOG environment is the possibility to create mobile support with its own GUI (graphical user interface). J2ME offers the necessary functions to create a simple animated chat client with a buddy list and write/receive options. With this application, the user can connect to his/her instant messenger account and communicate with any of his/her friends online. Assuming that the instant messenger is integrated into different MMOGs, it would increase the communication potential even further, because the user can stay in touch with any of the in-game friends without the need to run a game client. The major technical problem of this approach is the creation of a common namespace, because the in-game nicknames should be kept consistent in the instant messenger as well. However, some of the in-game nicknames might already be stored in the instant messenger. It is therefore necessary to create new instant 126
140 messenger accounts for all of the users. Each of the game accounts is linked to an appropriate instant messenger account, which will be created simultaneously. As a general naming possibility for the Eve Online example, the resulting user name would be The OSCAR protocol offers the user a direct forwarding method. As soon as the new account is created, each message can be forwarded to the user s original ICQ account automatically. As an example, the user HUGO from Eve Online creates a new account: Furthermore, the user already has an active ICQ account; therefore it is possible to forward any of the messages from the account to the user s original account. The creation of an additional account per player also creates overhead. Therefore, it is necessary to evaluate whether or not this overhead exceeds the usability of the approach. By creating a new account for each user, the in-game nicknames (like HUGO) can also be used in a chat session. This consistent naming helps the in-game user to identify the communication partner, because he/she has the same nickname as in-game. A player will therefore receive messages from buddies with the relevant nicknames, and therefore no name collusions occur. Furthermore, it is also not possible to assume the identity of another player, because as soon as the account is created, an additional account with the same name cannot be created. With the simultaneous integration of more games, further accounts will be created. It is also necessary to discuss whether these multiple chat accounts scale with usability. Since a player can have the name HUGO in three different games, a separate account with will be created for each of them. However, this is absolutely essential because one cannot assume that the same user is called HUGO in all three games. Particularly well-known, popular names are quickly taken after a game has been released. Players can also show a switching name behaviour from one MMOG to another; a fixed name approach would not support this behaviour. Generally, it is possible to merge any two given IM accounts by using a namespace server (like OPIS in case of AIM and ICQ). The namespace server forwards every message from one target account to another; in case of the Eve Online example all 127
141 messages from the newly created account would be forwarded directly to the user s existing account. 128 Game messages Figure 5.5. Creation of a common namespace by using a namespace server Figure 5.5 illustrates the common namespace and communication between the ingame MMOG client and the instant messenger client. As soon as the MMOG client tries to connect to the instant messenger server, a request is sent to the namespace server (in the case of AIM and ICQ this is OPIS). The namespace server communicates with the appropriate MMOG server in order to ensure that the password and user name are correct and afterwards, it replies with a list of forwarding targets (this list includes the user s normal instant messenger account). By using the flexible namespace technique, both important aspects for a consistent user naming policy are fulfilled: (1) Each user of the game receives a unique name that is the equivalent of his/her in-game nickname and (2) Each user can furthermore maintain already existing instant messenger accounts. The in-game representation of messages will be shown with the relevant nickname, whereas the common instant messenger client will still use the original account.
142 5.3 Implementation of a Mobile Gaming Communication 129 Based on the follow-up survey and communication situation in the mobile gaming environment, this section contains an introduction to the two research approaches. The MCChat offers a flexible solution for a mobile lobby to greatly reduce the matching time for mobile gaming. The IM integration in games uses the high importance of instant messengers for next generation game communication and closes the gap between in-game and real world buddy list contacts Approach I: MCChat A Mobile Communication Lobby The up-to-date mechanism for game finding in the mobile phone sector includes that each of the games features its own connection utility. Especially location aware games have a big disadvantage because potential players do not run the game client all the time and thus even if two players were at the same location (like subway train station or in the bus) the probability of having both with a running game client is very low. In order to increase the chance of finding other matching players, one should have a general software portal to track ongoing games. The software platform then offers interfaces to each of the mobile games, therefore giving all participants the opportunity to start the game session directly from the lobby. The mobile lobby approach features a text-based chatting application (like the Battle Net from Blizzard [Bliz]) to create a mobile forum. Game oriented handhelds (like the Nintendo DS and Sony PSP) already have their own individual lobby systems. Both devices use the WLAN technology (IEEE b) for network communication. A player with these devices can search for ongoing game sessions. Depending on the device, only a very limited number of configurations are needed. For example, the Sony PSP offers three WLAN channels (1,6,11) to support different game sessions at the same location. As soon as two players are connected in a game session, one of them can act as a host and start a common multiplayer game. A general game lobby for other mobile devices must be game-independent and capable of handling even larger numbers of incoming players (10+) without previous
143 network detection (ad-hoc network). Each of the clients can configure its game interfaces, thus each other player can see the installed mobile games, which further speeds up the selection of potential opponents. Moreover the lobby acts as a portal, where every player can chat while waiting for the next game to start. The mobile gaming lobby uses the DirectPlay API [Dire]. This API is designed to support communication in multi-user applications such as games. The application can use the given methods to send information without the knowledge of the underlying network. The lobby application is designed in Virtual Studio.NET 2005 with the DirectPlay for Pocket-PC-SDK. It uses TCP/IP as the transport protocol. The implementation itself contains the WinMain() function to start the graphical user interface. This is displayable on PDAs as well as notebooks; integration into mobile phones is also possible. A player can use the search button to look for game sessions. If a game session is already ongoing, then a player can select the session and join the chat (this is implemented with the JoinChat() function). It is also possible to host a session (with the HostChat() function) in order to wait for others to join. The host of the game session will also be the host of the mobile game. If the host disconnects, the session will automatically be closed. The underlying functions for the network setup use the DirectPlay methods. Basically, as soon as a player starts to host a session, the DirectPlay method automatically assigns a port between 2302 and The search method uses a broadcast to identify all ongoing game sessions and lists the result for the user. Once a player decides to join a session, a direct connection to the host is established. The name table for the existing players is updated and the new player joins the chat. This example can be found as a flow diagram in the appendix (Figure 9.22). For detailed information about the implementation refer to [Lehm 2006]. Game sessions are started by a player who acts as a host and waits until enough other players have joined the game session. By starting the game from the mobile lobby, the chat application will also terminate itself and all gathered players join the target game. Figure 5.5 illustrates the prototype of the mobile gaming lobby. 130
144 131 Figure 5.6. Screenshots of the mobile gaming lobby Both PDA and mobile phones have the opportunity to run customized software from 3rd party applications. The mobile gaming lobby was designed in.net and uses the J2ME platform to support as many mobile devices as possible (PDAs and mobile phones). The underlying network technology is WLAN, because every current PDA as well as most of the next generation mobile phones supports this technology. It would also be possible to integrate Bluetooth as the network technology. The advantages of WLAN (higher range, common standard among PDAs, etc.) are responsible for the design decision [Fritsch ]. The mobile lobby is implemented in.net. The prototype is designed to run on PDAs. This decision is based on the technical equipment which is available for the testbed. One should keep in mind that due to the usage of J2ME, it is also possible to convert the lobby to a MIDlet that runs on mobile phones. For evaluation purposes (testbed) the implementation runs on PDAs. The devices deployed are ipac PocketPCs H4155 with 400 MHz Intel processor, 64MB RAM and a 240x320 pixel TFT display. Each player only has to select a nickname and they will automatically be connected to the lobby. In the current version, the application contains a single chat-room, where all players can meet. No further configuration is needed; the underlying adhoc network manages the IP addresses on its own. Therefore, the lobby offers a fast and very simple way to get in contact with as many other players as possible.
145 5.3.2 Approach II: In-Game IM Instant Messengers in MMOGs 132 By integrating instant messengers into a MMORPG, a highly flexible solution is needed which is as expandable as possible for both new instant messengers and new MMORPGs. However, the current work focuses on the integration of a single instant messenger (the AOL IM) into a target MMORPG (Eve Online). Before taking a closer look at the general idea of a next generation in-game message interface, one must analyze the given structure of the target instant messenger. The AIM was initially only available for AOL customers; nevertheless after 1998 the instant messenger was opened up for a wider audience. Besides ICQ, the AIM is available for every common operating system (including mobile systems). Basically, AOL and ICQ use a single closed-source protocol called OSCAR (open service for communication in real-time). Several servers are organized in the accordant network: one central authorization server and several BOS (Basic OSCAR Service). Figure 5.7 illustrates the login procedure. Admittedly, there is no reliable documentation available; although since the SDK for third party applications was released in 2006, there is a second protocol. The TOC protocol is a text-based wrapper that uses gateway servers to translate TOC commands into OSCAR packets and vise versa. Its complexity is therefore reduced for the basic IM features (like login, send, receive and buddy list functions). Figure 5.7. Login at central authorization server. By submitting the password successfully, one receives a cookie and is redirected to a BOS Based on the idea to implement an instant messenger into MMOGs, it is necessary to design a middleware application between the game engine and the OSCAR SDK.
146 The design provides general interfaces in the game for all chat functionalities such as send, receive, login, and add. The other part of the middleware is the interface to the TOC gateway. This is implemented by OSCAR SDK, which features the basic commands. The general implementation approach is illustrated in Figure 5.8, where the Eve Online client is combined with the interfaces of the TOC gateway servers. By using the basic TOC commands, a player does not need to have a separate ICQ or AIM. Instead, the user can log in with his/her existing account with the Eve Online game client and the middleware will offer the necessary chat functionalities. As a result, the chat will be visible in-game instead of via a 3 rd party application. 133 Figure 5.8. Integration of the AIM into Eve Online: communication takes place through simple TOC commands Due to its basic command structure, the game client (Eve Online) has many ways to implement the graphical part of the user interface, either by using the standard buddy list options with separate pop-up windows and mouse support or by breaking it down into an IRC text-based chatting system. As a result, the user can chat with his/her buddies without the need to install separate instant messenger software. In a mobile context on the other hand, a simple GUI is created, which allows resourceconstrained devices (like PDAs and mobile phones) to run an instant messenger chat. Game-related activities can therefore be performed while being mobile and the user has the opportunity to stay in touch with in-game friends. The IM interface design is split up into three main classes: ClientManager, ClientInterface and BuddyList. As one can see in Figure 5.8, those classes form the
147 center of the UML diagram. By further analyzing the three classes, one will see the distinct function that each of them fulfils: 134 ClientManager -_instance : ClientManager -_clients : ClientInterface -_busy : boolean +getclientmanager() : ClientManager +connect(in client : ClientType, in username, in password) : ClientResult +disconnect(in client : ClientType) : ClientResult «interface» ClientInterface +connect(in username, in password) : ClientResult +disconnect() : ClientResult +isonline() : boolean BuddyList -_buddylist : BuddyList -_buddies : Buddy +getbuddylist() : BuddyList #addbuddy(in name, in client : ClientType) : ClientResult #removebuddy(in buddy : Buddy) : ClientResult MsnClient AimClient Buddy Figure 5.9. UML diagram of IM Chat integration The ClientManager is responsible for authentification; thereby it is vital that only one instance exists in parallel. It handles the login with the client, its username and its password by creating an appropriate ClientInterface. The ClientManager offers the central interfaces to the game engine. All basic functionalities (such as send, receive, login, logout, etc.) are requested directly at this class. However, the options are limited to AIM interfaces. The current version of IM Integration only supports the AIM and ICQ chat client, but the generic structure easily enables further integration of any other client. According to Figure 5.8, this class represents the interfaces to the game engine. Only graphical implementation is missing because it needs to be implemented individually for each MMOG. The ClientInterface, on the other hand, is responsible for direct communication with the TOC gateway servers. Once an interface method at the ClientManager is requested, the relevant procedure at the ClientInterface class is requested to communicate with the TOC server. The ClientManager translates the interface commands from the MMOG into commands that can be understood by a TOC gateway server. It uses the TOC command structure in order to send and receive data from the network, hence offering all necessary interfaces to the TOC servers. An
148 example would be a simple connect operation, which is requested by the ClientManager and translated by ClientInterface class. 135 Figure Sequence diagram of the login procedure for IM integration The sequence diagram in figure 5.10 illustrates the data flow during the login procedure. The game engine tries to log the user in at his/her instant messenger account as soon as he/she logs into the game. The initial request uses the interface at the ClientManger class. The relevant information plus the ClientType are forwarded to the ClientInterface class. This class chooses a corresponding message type (in the case of the flow diagram it is ICQ/AIM) and communicates with the gateway server. Initial information from the MMOG engine is translated into commands that the TOC server can interpret. After an acknowledgement is returned, the ClientInterface notifies the ClientManager and so on. The third main class is the BuddyList. This class manages contacts in the current users friends list. Only methods like add and remove are supported. This class has a slightly different function, as its functions have nothing to do with the direct chat mechanisms. The message structure for these functions for the TOC gateway server differs slightly from the simple communication commands, therefore a disjunction into the two sub-classes BuddyList and ClientInterface is chosen.
149 The IM interface was intentionally designed to fit into the Eve-Online client; however, due to the lack of cooperation from CCP gaming, it was ultimately not possible to integrate the client into the game. Alternative open source applications for large MMOGs did not exist; most of the projects were still in the developmental phase. Therefore, the implementation of a simple GUI (in addition to the graphical interface for mobile clients) was required. To substantiate the functionality, this simple GUI was designed. Moreover, a testbed was required to further verify the performance of available features. The analysis of testbed results is discussed in chapter Summary The chapter on next generation mobile games introduced the special motivation regarding the mobility aspect. It was determined that the problem of insufficient mobile network support is mainly responsible for the current lack of mobile MMOGs. In order to improve the current mobile gaming scene, a survey evaluated the users behaviour. Based on the results, two main approaches have been introduced. The MCChat features a mobile lobby platform to significantly reduce the setup time of mobile game scenarios. On the other hand, the integration of instant messengers allows the players in mobile environments to communicate with in-game friends (even those from Internet MMOGs) without running the game client.
150 Approach III: 4MOG Middleware Think? Why think! We have computers to do that for us, Jean Rostand. This chapter covers the 4MOG middleware approach, which offers a software solution with interfaces to the game client (upwards) and network layer (downwards). The approach includes the design of a middleware application which reduces technical implementation efforts. Thanks to this reduction, the designer can focus more on the content of the games, hence increasing their quality. The first section outlines requirements of the middleware and illustrates the planning process. In the second part of the chapter, the design and implementation is described in detail. Finally, the validation section contains a comparison with a similar middleware as well as a testbed setup. Results of the testbed are described in chapter Requirements The first step in creating a middleware application is to define its requirements. It is necessary to analyze the situation in order to determine whether if a problem actually exists. If a problem exists, it is necessary to evaluate it closely and to create a solution as precisely as possible. Therefore, this section contains a detailed overview of the problematic field. Its purpose is to outline the motivation in creating the middleware. Functional requirements are then introduced briefly. The section describes the middleware s interfaces, which also contain information about the core functions. Each of the functions is described in detail to clarify middleware usability. Furthermore, non-functional requirements are introduced. This section contains information about additional aspects like the human factor, documentation or hardware considerations. These aspects also need to be addressed since they can be important influencing factors for the usage of middleware. Especially the human factor (player behaviour) plays a vital role in the gaming context [Fritsch ].
151 The constraints of middleware are introduced as well. These constraints pinpoint restrictions that the middleware has, in order to clearly describe what exactly the middleware can do and which features are not supported. This section shows the limitations with regard to the client, the network, the protocol and the hardware. Finally, this section features a detailed usage case model to illustrate the benefits from the middleware application. A most understandable description of the software helps to support a smooth implementation Overview and Motivation Two main aspects need to be considered to understand the motivation of creating a middleware application. The first aspect is whether or not the middleware is necessary at all, because non-repeating problems can also be solved with a specific single solution. The second aspect is the decision as to which functionality a middleware should have. Compared to the current stand-alone game architecture, a middleware is an additional software interface. Generally, the middleware application needs to improve the initial situation. In the case of gaming, this can either be done by defining standards for multiple games (especially important in the mobile phone sector with hundreds of different devices) or by creating a performance improvement. However, it is necessary to keep in mind that a middleware also has developmental costs. In order to be useful, the middleware s functionality needs to compensate for these costs. Currently, most of the commercial games do not use any middleware for two main reasons: (1) The game industry often produces clones of existing game types. Successful software pieces, like a game engine, are often resold for smaller game producers. (2) Fixed costs of game development are very high compared to the variable cost of duplicating a CD or DVD. This leads to the fact that most commercial game producers are not willing to share their solutions with others for free because they have already invested money in them. Commercial software solutions exist (like game engines), which are sold
152 to multiple game companies, however, especially the small companies cannot afford them and they would need a freeware solution. The development of a gaming middleware needs to take these aspects into account. In order to create a successful middleware application, the functionality must improve the current game development situation. One method to achieve this is to reduce the effort needed to produce a game (because the other method would be to enhance the performance, which is more complex to implement with middleware software). The general problem for small game companies is the high initial developmental cost for MMOGs. Currently, standard features in MMOG development include technical aspects (such as connection, authentification, and storage), the creation of the content (design of the game world and the NPCs) and the balancing (beta testing of the content with player feedback). In order to reduce the overall cost, the middleware application needs to cut implementation costs (for example by creating a solution for the technical aspects), so the developer can focus more intensively on the other parts. A game designer from Electronic Arts [EA] stated that about 80% of the game development effort is individual content. This includes the design of the online world, the setting, the storyline and interaction in the virtual environment. In fact, the creation of individual content cannot be automated. As an example for an MMORPG, the design of content includes the creation of quests for the players. Each quest contains an individual storyline, sometimes multiple triggers for events during the quest as well as a NPC to interact with. Once the quest is designed, most of the work cannot be used for another quest because players expect varying content. Most of the players strongly demand non-repeating content in the games. In order to be innovative, one can frequently not reuse already existing content. The general principle of in-game interaction between a player and a NPC remains similar. However, the difference between quests is the individual quest text, the dialogue, the quest content (player s duty), etc. Therefore, one needs to look at the remaining 20% of the game design effort. Most of the remaining tasks are technical implementations such as login methods, player authentification, in-game object management and a chat system. These functionalities can be found in any of the current MMOGs. Due to their frequent 139
153 usage, these features offer an opportunity to reduce the development effort. Since it is expected that every upcoming MMOG will also adopt these features, a common middleware solution would reduce the developmental costs. A good example for the current game development situation is the creation of the current top-selling MMOGs. As an example, the creation of Everquest 2 [Ever] included the casting of Hollywood actors for the in-game characters. More than 250 programmers participated in the project [Soe], overall production costs have exceeded $100 million. Since this is just an example, other games have similar costs. The game developing industry recognizes this trend. Current top-selling MMOGs need to sell at least 1 million copies to cover the initial costs [Digi]; this number is expected to swing up further in the future. Therefore, a common reduction of costs is needed to give the developers the opportunity to focus on the creation of game content. Before focusing on the concrete software design, it is necessary to pinpoint the stakeholders of the middleware application. The large game producers like Sony Online Entertainment and Electronic Arts frequently release online games. Therefore, they already have customized solutions for the technical background of their games. As an example: Sony Online Entertainment released Everquest 1 in 1998, the underlying zone system, the server architecture and the login methods are reused in all of their other MMOGs (like Planetside, Everquest 2, Star Wars Galaxy, etc.) [Soe]. Due to their already existing customized solutions, it is unlikely that large game producers will require a middleware. However, the creation of MMOGs has increased drastically over the last five years. As [MMOR] shows, currently more than 200 different MMOGs have already been released or are in the developmental phase. Most of them are produced by smaller companies. Since it is time-consuming to create an MMOG (on average a game needs 3-5 years of development), cost reduction is especially interesting for smaller companies. The objective of smaller game producers is to create high quality game software that can compete with top-selling MMOGs. Large companies like ID software [ID] are developing the next generation in gaming engines on a regular basis. Their main income is based on re-selling the engine instead of creating game applications on 140
154 their own. A middleware application with the basic technical functions (player administration, chat, object management, etc.) would reduce the costs of creating a game because the smaller companies would not need to purchase these functionalities from big retailers. This would especially support the smaller game companies in producing MMOGs and it would give them the opportunity to focus more on creating content in their software. Figure 6.1 illustrates the advantages of middleware from the different perspectives (the user and the game designer). The middleware s functionality offers a basic core set of functions for the game design. This core set includes a simple player authentification, player tracking, network support (simple server-client structure) and basic chat features. 141 User Quality software Focus on content creation Game Application Offers features Uses middleware Game Designer Offers interfaces (Core set of functions) Middleware Figure 6.1. The 4MOG application and advantages from the user s and the game designer s perspective From a game designer s perspective, the middleware offers interfaces for standard game features (such as chatting). By using these interfaces, technical implementation effort can be reduced. Especially in MMOGs, the balancing aspect (a fair design of the different player classes) and the creation of an online world is time-consuming. The advantage of a middleware system for the designer relies on the set of core
155 functions. Simple implementations for some of the functions (i.e. connect) exist, although a complete core set covers a larger problematic field. By using the middleware application, the designer is supported in game creation process. The middleware s interfaces can be used without precise knowledge of the implementation of each function (black-box principle). Since multiple interfaces exist (and not only a single connect function), the technical implementation effort is reduced. From a player s perspective, the software s quality level is expected to improve (assuming that additional time is used for content creation). A well designed MMOG requires sufficient time to configure the content accordingly. The middleware does not influence the content directly; it shifts the developer s focus: from technical implementation to more individualized content creation Functional Requirements After an initial introduction to the problematic field of the current MMOG design, one must precisely define the functionality and requirements of the middleware. The core set of the middleware describes the basic functions for any MMOG (such as authentification, player tracking and chatting). These functions must be designed with regard to the current game development. As an example, the chat function must support different channels (i.e. personal chats, group chats), since most of the online games allocate communication that way. With regard to the evolution of mobile gaming, these features will be important in the future as well since mobile games are often clones of successful PC or console games [Jamb], [Harm 2004]. The player s and the designer s perspective are different points of view for the middleware. The middleware directly influences the developer, whereas influence on the user is indirect. The middleware offers the following core functions: Administration of Player Data: The administration of player data can be performed by the middleware if the developer uses the interfaces. This administration includes the storage of all relevant data for each participating player, such as character level, class, location, etc. Generally, the middleware functions must be generic so that they can also support other in-game objects (like barrels, chests, etc.). Therefore, the
156 middleware can also keep track of these objects. A generic class design also offers the opportunity to customize this administrative function, depending on the MMOG. As an example: the function position() could either contain 2D or 3D coordinates. The main disadvantage of object tracking in MMOGs is scalability. With a growing number of objects, the server s response time increases. Common design strategies for this problem are either instancing (creating a copy of a part of the online world for a group of players) or distribution of players with in-game events (creating multiple spots of interest so players are allocated more evenly across the game world). After separating the players, the in-game load is distributed on different servers. Combined with the middleware s monitoring aspect, it is possible to detect timebased cheating (like speed hacks for a higher movement). By tracking the relevant data, it is possible to roll back the data if the movement speed exceeds the game limitations. Send and Receive Operations: The middleware application should handle messages between the server and the client implicitly. In particular, it has a standard repertoire of message types (like status updates, login methods, etc.), which the developer can use. These standard messages contain a fixed syntax so the middleware can identify them. As an example: the login method must at least contain the user name and password. In order to not limit the application types, the middleware must offer an opportunity for additional message functions. These individual messages can be created by the developer, whereas the middleware offers a guideline to create them. The send and receive operations are required for every MMOG. An implementation of communication between server and the clients is the middleware s focus. This focus includes the design of messages between server and client (plus the opportunity to create individual message types). Creation and Termination of Game Sessions: Depending on the game type, it is necessary to also implement typical client- and server-based functionalities like the creation of a new game session. Further game relevant parameters such as a maximum number of players or the connectors for the next zones (if the world is zone-based), should also be offered as an optional feature. Clients can request a server list and then authenticate at one of the servers. 143
157 Communication Functionalities: The communication aspect is also important for the design of the middleware application. General in-game send and receive functions as well as a channel system offer typical communication methods of current MMOGs. Due to the expandability it is generally possible to integrate further communication concepts (like the IM in-game integration) into the middleware as well, which further supports communication with out-of-game friends. Monitoring: Another feature should be the monitoring of player relevant data. By tracking each player s in-game activities, this method can help to gather important information about the in-game world distribution (which is required for load balancing) or the usage of certain abilities (which is required for in-game balancing of the content). As an example for in-game distribution, the middleware could store player distribution in the online world in a log file. A developer could analyze the log files afterwards. Additional in-game content in other parts of the online environment can help to even the loads. Since the monitoring aspect features a wide area of subproblematic fields (like further features such as cheat protection, load balancing, content balancing, individual in-game content, etc.), the focus of the middleware relies on connectivity between clients and the server. The middleware s monitoring function is reduced to a tracking of the in-game distribution of players Non-functional Requirements This section covers the middleware s non-functional requirements. These are immanent factors of the problematic field. Thus, their actual influence on the middleware cannot be analyzed completely during the planning process. Nevertheless, it is important to discuss them during conceptual planning since they will have an influence on the software usage at a later stage. Human factor: The middleware is not completely autonomous; a major part of its functionality depends on the way it is adopted by the developers. Since the middleware aims to support game developers, one can assume that most of them will have expert knowledge of computer game structure. It is not expected that hobby programmers use middleware on a regular basis because the design of an MMOG is overly time-consuming for just one person.
158 A detailed description of methods helps to clarify the middleware s functionality. The developers will be more likely to adopt the design structure if class diagrams provide a design overview. This is important for the interface design because the designer needs to understand what the middleware interfaces offer in particular. In contrast to released software which needs to offer functions that have already been implemented, the middleware contains abstract methods that can be implemented further. The middleware s final version needs to feature well documented classes [JavaD] in order to clarify the methods. The middleware should offer a simple GUI to support the monitoring functionality. The framework and interfaces of the middleware do not necessarily need a graphical representation because well documented classes and adoptive interfaces are more important for the game developers. Performance: The middleware needs to support all of the current MMOGs. This leads to performance requirements; especially player and object management are calculated in real-time. With regard to [Beig 2004], the players latency should not exceed 300ms because performance decreases continually with an increase in latency. As a result: all of the middleware s player functions that call for acknowledgements in real-time should be aware of this latency. The middleware also has interfaces to the network. In the case of MMOGs, a serverclient structure is assumed because every commercial MMOG uses this network structure. Generally, a P2P solution is also possible, although security issues (MMOGs often have strict authentification methods) clearly do not promote this structure. Another aspect is the middleware application s scalability. Most current MMOGs feature between 1,000 and 15,000 players simultaneously. With a growing number of users, the response time increases (which has negative effects on the players performance). Since the MMOG server is the network architecture s bottleneck, the middleware needs to support rapid communication between clients and the server. The size of the packets should be as small as possible to reduce the effect of an increasing number of players. Furthermore, the degree of communication between the middleware and the server must be minimized as well. Both TCP and UDP are 145
159 used as protocols in the middleware since they are the standard for current MMOGs [Game]. Security: The middleware s security is vital from a developer s perspective. The player and object tracking mechanism especially contains important data about the in-game world. This data needs to be safeguarded because a player could obtain an advantage over others by knowing the precise location of objects (such as treasures). Therefore, the methods for players are not allowed to access this secure information. Furthermore, the middleware needs to be robust with regard to the large number of players. If the middleware design does not scale with a large number of players, it could shut down during the peak times. A negative example of a shutdown is the server structure of Diablo 2 [Diab]. Players could shut down the main game server by sending too many messages in a short period of time. This brute force technique has led to the misbehaviour of constantly rebooting the main server to obtain a game advantage. As an example: instead of permanently losing a character (due to demise), the game server was attacked to force a roll-back. Such behaviour needs to be anticipated for the middleware as well. It must be robust against a high number of incoming packages. One possible technique for the middleware could be the regulation of player spamming behaviour (see Section 6.3.2) Constraints This section covers constraints for the 4MOG middleware. When analyzing the problem, limitations need to be pinpointed. The more generalized the task for the middleware is, the more difficult it is to find a solution for the overriding problem. Therefore, the 4MOG middleware will focus on certain aspects which have been implemented in detail: Client restrictions: The 4MOG middleware is designed for a server-client structure. The clients are assumed to be high-end personal computers, which are capable of running current graphic engines. It is theoretically also possible to use the middleware on resource-constrained devices (mobile phones, handhelds, etc.) as well. But the problematic field in the mobile environment is completely different. In particular, the performance of handhelds is not high enough to support a current game engine. Furthermore, communication with the clients poses additional
160 problems (GPRS has a high latency, WLAN and Bluetooth only have a limited range). Assuming that personal computers are up-to-date, local calculation can be carried out by the clients. This reduces the server s load because many calculations can be performed by clients themselves. Especially rendering (illustrating the game world) and movement prediction can be calculated by the client, which reduces network traffic. As an example: the movement of other players can be sent via a simple message from the server to the client, containing only the new coordinates. The local rendering and the prediction for further movement can be carried out by the client itself. Network restrictions: A decision on the middleware s design (server-client) is based on the fact that the server-client structure is the common design among current MMOGs. A hybrid or peer-to-peer network would reduce the server s bottleneck position, but the downside is a security problem and the problem of storing persistent game data. The security problem includes the fact that peer-to-peer networks offer more options for the players to cheat within the game. Furthermore, a central login method is missing. As many MMOGs have a monthly fee, they also need to ensure that playing for free is not possible. The underlying protocol for middleware is TCP and UDP since both protocols are frequently used in the current MMOG design. The main difference between them is that TCP is connection-based. It uses the acknowledgement function to ensure that no packages are lost during the transaction. UDP is faster because it does not use explicit server-client connections. Depending on the game scenario, the developer has to decide whether TCP or UDP should be used. As an example: the coordinates of player movement do not necessarily need to be sent to different clients individually. Broadcasting for all clients within the AOI (area of interest) in regular intervals reduces overall network traffic. UDP would be preferred for this scenario since a player s movement information will be updated frequently. Even if a single packet is lost during the transaction, it is possible to smooth the in-game movement after receiving the next location update (this technique is called dead reckoning). Middleware limitation: The middleware is limited to a core set of functions (administration, send/receive, game sessions, communication, monitoring), which 147
161 support the game developer by offering interfaces for the game s technical implementation. These methods could also be used to integrate more functionality. As an example: the gathered data of player monitoring could be analyzed and used to integrate more individual content in the games. In the current 4MOG middleware application, additional methods have not been included for two reasons: 1) The integration of too many different functions in the middleware reduces its credibility. The existing functions cover the described problematic field; they support the developer in the game design phase. More functionality would significantly increase the programming effort and would not support all types of MMOGs. As an example: an additional ladder system (in-game playing ranking) supports the design of FPS and RTS games although it is not required in the design of MMORPGs. Therefore, it is necessary to focus on the implementation of the core functions first. 2) Before the middleware can be expanded with further features, it is necessary to analyze how the developers actually use the 4MOG application. This can be done by receiving feedback (from the developers) about the middleware s current version. With a deeper insight into actual usage, a follow-up application with further features can be designed System Model This section covers the illustration of the 4MOG functionality with a usage case diagram. In the design phase, it is important to clarify the methods for all participants. In the case of the 4MOG middleware, game developers are the target group. The software offers five different types of functions: administration, send/receive, game session, communication and monitoring functions. Figure 6.2 shows the core set functions and their connection to the game developer. Since the GameDeveloper is the central actor, he/she is supported by the middleware. As an example: the administrative functions include methods to handle in-game objects (like player characters, NPCs, etc.). If a player picks up a new item, the middleware function to update the inventory can be used to store the change.
162 149 Figure 6.2. Usage Case diagram of the 4MOG middleware The user does not use the middleware s interfaces directly. The objective of the 4MOG design is to make the game design easier. The middleware can be regarded as a developmental tool since the interfaces offer an easy way to integrate the rudimentary technical functions of the MMOG. It is necessary to clarify that the developer also needs to connect the given interfaces of the middleware to the game engine (the game engine is built on top of the middleware). As an example: if the user wants to chat with in-game friends, he/she uses the ingame communication methods (like sending a text to a fellow player). This means that the interaction from a user s perspective is limited to the game engine. The game engine on the other hand uses the middleware s interfaces for this communication, in particular, the game engine requests a function of the middleware with the parameter of the target player and the message string. The middleware communicates with the server (in order to receive information as to whether the target player is online) and forwards the message to that player.
163 Design The design section must be differentiated from the requirements section. This part of the middleware design includes the concrete decision about the structure of the middleware and its specific implementation. Before one can look at the modularization, a few fundamental implementation decisions need to be taken: Programming language: The major aspects for a decision on the programming language are compatibility and performance. The middleware needs to be compatible with the current computer game design. Since the constraints include a focus on the current MMOG design for personal computers, one needs to look at the programming languages deployed. Most of the high speed games (FPS, RTS) are implemented by using C++, whereas Java plays an important role for simulations and MMORPGs. Platform independence is also important; several MMOGs (like World of Warcraft) also support the Mac OS. Platform independence would further support Java as the programming language. The aspect of performance also influences the decision. C++ supports latency sensitive games better than Java because the game applications run faster. The overhead of the Java Virtual Machine is a problem in the game design, especially for resource-constrained devices. Therefore, the performance aspect clearly promotes C++ as the programming language. When considering the constraints, the assumed hardware specification of the client includes an up-to-date personal computer. Furthermore, most of the MMOGs released are RPGs (which are not as latency sensitive as FPSs and RTSs); therefore compatibility is more important than performance. With regard to the trade-off between performance and compatibility, the 4MOG middleware uses Java as the programming language. RPC vs. MOM: A further factor besides the programming language decision is the communication design: the central aspect of this decision is whether the middleware should be implemented as a MOM (message oriented middleware) or as a RPC (remote procedure calls) version. The RPC implementation of the middleware is the classic implementation strategy for client-server systems. Generally, a RPC is
164 initiated by the client, which sends a request message to the server. This request uses one of the interfaces provided by the server with specific parameters. As an example: the client uses a send(<playername>, <message>) method on the server. The advantage of this technique is the clear separation between client and server, which enables the client to only call up pre-defined methods on the server. Results are calculated by the server and the client receives an answer afterwards. In the example, this answer could include a simple acknowledgement or an error message if the receiver is offline. The MOM design includes the usage of messages to communicate between server and client. A queue system stores the messages from the clients on the server, so they can be executed in proper order. The advantage of MOM implementation is the ability to store and transform the messages. Since the size of each message is small, their storage is easy and a logging mechanism is possible. Two main aspects promote the MOM implementation over the RPC version. The smaller package size of the MOM implementation reduces overall network traffic. This is important for MMOGs since the scalability (number of players that participate in the virtual world) affects all types of games in this genre. Furthermore, the MOM system offers greater flexibility for the clients [Hsia 05]. As an example: after sending a message to the server, the client can use forecast algorithms that include the most probable answers. In case of movement in the games, a client could calculate the movement of opponents while waiting at their exact position (answer from the server). Once the answer is received, the difference can be reduced by synchronizing the local calculation and the exact data from the server. Both of the arguments clearly promote the MOM implementation over the RPC version Modularization Modularization describes the middleware s general structure. This section contains an overview of the client and the server side of the 4MOG application. Since the server-client structure is implemented as a MOM, both sides use a MessageListener for communication. This listener is an implementation of the
165 standard observer pattern. In order to receive an overview of the middleware s modularization, Figure 6.3 introduces the complete UML diagram of the server. 152 Figure 6.3. UML class diagram of the 4MOG server side The server uses the MessageListener to communicate with the clients and offers interfaces for functions as shown in the UML diagram. Two main classes are in the central position of the UML diagram. The GameState contains all important information about the player location, objects and the status of the virtual world. This class offers functions for both clients and the server to receive information about the current game world. As an example: the GameState contains information about the position of all other players, and the server can receive specific information if needed (like the position of all team mates). This information is stored in the GameObject class; player characters as well as attributes are also stored. The separate storage of object attributes enables parts of the game object to be updated without submitting the complete object whenever it changes. As an example: if a player receives a negative effect which reduces a certain attribute, then it is possible to submit the temporary decrease to the database without having to update the entire character immediately.
166 The network communication of the server side uses UDP and TCP interfaces. In the case of TCP, the server administrates all the connections to the clients. This includes the distribution of ports and the clean up after a connection session is closed. The exact functionality of each class is described in the next section. The client version of the middleware has a similar structure because the client also has interfaces to the GameState, the network and the MessageListener. The functionality of the client class differs significantly. Figure 6.4 gives an overview of the structure of the client side of the 4MOG middleware. 153 Figure 6.4. UML class diagram of the 4MOG client side The client shows similarities compared to the server side of the middleware. One common aspect is the MessageListener, which is needed for communication between server and client. The client uses the MessageListener to send status updates like movement to the server. The transfer of data through the network is implemented with the UDP and TCP client manager. The main difference between the server and the client side of the 4MOG middleware is the access at the GameState. The server has full access to all information (including all objects and players), whereas the client only has a limited number of
167 interfaces at the GameState. These functions contain non-critical information like the in-game time or information about the own character. As an example: the client could use the /time function to receive information about the in-game time because the virtual world s time could differ from that of the real world Functionality This chapter contains information about the functionality of all classes in the middleware. Each of them is described in detail: GameState: The GameState class contains information about the game world, including the location and status of all objects. Figure 6.5 features an UML diagram of the GameState class; it is shown that both players and object have certain common attributes. Figure 6.5. UML diagram of the Gamestate class Both the client and the server can communicate with the GameState class (refer to figures 6.3 and 6.4). The main differences in communication with the GameState are the available interfaces. The server can access all information about the game world, whereas a client only has access to general information (like the in-game time). This security design is necessary in order to prevent cheating. If a player would have
168 access to all information about other players and objects, he/she would obtain an advantage compared to the others. The functions of the GameState class contain all necessary methods to administrate game objects (including players). A player can join, leave or move in the game world. The relevant changes are carried out by the GameState class. Client and Server: The client class is an implementation of the network functionality for each of the clients, whereas the server class represents the server s network functionality. Both of them communicate with the GameState. Before a client can join the game, it is necessary to establish a connection. The middleware uses a ConnectionSession for TCP connections between the client and the server. This class creates a logical connection between the server and the client. Since UDP message transfer is also supported, a TCP connection is required to establish the initial connection between the client and the server. 155 Figure 6.6. UML diagram of the server and client class The middleware implementation of the connection is realized with a multi-threading approach. Each new client that connects to the server receives an individual thread that handles the connection. Figure 6.6 illustrates the connection of the client and the server to the GameState. The client uses a separate thread for the TCP and the UDP connection to the server (TCPClient and UDPClient), which awaits messages from
169 the server. On the other hand, the UDPServer also monitors incoming messages from the clients at a specific port. The initial TCP connection is realized through the ConnectionSession class. As soon as a new player joins the game, the server creates a TCPConnectedClient thread that handles the socket and initializes the connection. Furthermore, the player registers at the GameState class. If the registration is successful, the player then receives a unique ID and the client creates its network threads. If the player is rejected by the GameState (banned or the maximum number of players is reached), then the ConnectionSession is terminated. StandardClient and StandardServer: In contrast to the pure network functions of the server and the client class, the remaining functionality for the server and the client are implemented in the StandardClient and StandardServer class. In the middleware architecture, the StandardClient uses the client as an interface for the network functionalities. In order to illustrate the differences in the classes, figure 6.7 gives an overview of the StandardClient implementation of the middleware. 156 Figure 6.7. UML diagram of the StandardClient class The StandardClient represents the middleware application from the perspective of a client and offers the standard functions to join, quit or move in the game world. As
170 shown in figure 6.7, the network aspect of the client is implemented by the client class, whereas communication with the game is carried out by the GameState class. Furthermore, the game application can define customized messages that implement additional functions for the client. This option allows the designer to customize the client for the corresponding MMOG. The design of the StandardServer is analogous; figure 6.8 illustrates the UML diagram: 157 Figure 6.8. UML diagram of the StandardServer class 6.3 Validation In this section the middleware application is validated in order to ensure credibility. The validation process is one of the most important aspects in software creation because an innovative application s credibility relies on its results during this process. Therefore, the application is compared with a similar middleware called GASP [Pell 2005]. The functionality and constraints of both applications are evaluated. Since the constraints have a significant influence on the usage of the middleware (because they describe the limitations), one first needs to analyze the two systems individually. As similarities exist, the implementation principles are discussed in particular.
171 The comparison of both middleware applications is also discussed with regard to specific scenarios. Both applications have a slightly different usage case scenario, which means that it is difficult to illustrate a common performance test. The comparison will therefore be based on an argumentation. Nevertheless, it is still important to evaluate the 4MOG middleware s functionality: Therefore, the creation of a testbed is described, which is used to further validate the 4MOG middleware application. The testbed focuses on one of the core set functions of the middleware: player tracking. In order to illustrate a potential scenario for the middleware, a certain spamming behaviour is assumed. Spamming describes the player s behaviour to continuously send a large number of packets to the server. In this testbed, the 4MOG middleware s functionality is used to minimize the effects of such player misbehaviour Comparison with other Middleware This section includes a comparison of the 4MOG middleware with other middleware applications. Each of the following subsections includes a short introduction to its middleware. Subsequently, the main differences between the respective middleware and 4MOG are introduced and finally common aspects are highlighted. The comparison focuses on clarifying major differences between 4MOG and related software approaches Comparison with Zoidcom Introduction: Zoidcom was originally a by-product of the multiplayer space shooter "Operation Black Sun. After attempting several approaches to implement efficient networking into the game engine, the 4th iteration of the net code became a standalone library. With this library, Zoidcom aims to provide most of the current space and FPS games with network functionality. Differences: The developmental strategy of Zoidcom is based on the generalization of an already running implementation. Thus focus of the library relies on the support of space and FPS games. Zoidcom itself is designed as a library, whereas 4MOG is a middleware. The main difference is that 4MOG already implemented the methods and offers interfaces. On the other hand, Zoidcom offers a well documented library with a set of functions to manage the games network aspect. These functions include
172 bit streams; a technique to use a UDP-based protocol with advanced functionality. With the additional functions, the bit stream protocol measures the ping time between clients and servers regularly in order to improve/decrease the data traffic. Furthermore, an automatically bundling of very small data into packets is used to even the loads on each packet sent. Zoidcom is based on a very protocol driven approach, whereas 4MOG uses a set of core functions which are important for all MMOGs. The game focus between both projects is also differs slightly because Zoidcom offers functionality for FPS and space simulations. On the other hand, 4MOG offers core function support for MMOGs. Similarities: Both projects have certain aspects in common. The concept of player tracking is available in the Zoidcom library as well as in the 4MOG middleware. In both cases, a client side prediction (dead reckoning) is used, but data for movement and error correction is double-checked with the server at all times to prevent illegal player activities Comparison with ENet Introduction: ENet evolved as a UDP networking layer for the multiplayer FPS game Cube. ENet's purpose is to provide a thin and robust network communication layer on top of UDP. Similar to Zoidcom, the evolution of ENet is based on an implementation of a FPS game. Differences: ENet uses UDP as the protocol and also provides a simple connection interface over which communication is possible with a foreign host. As long as the data stream is active, ENet monitors the network conditions from one host to another, including a measurement of round-trip times. In contrast, 4MOG uses a TCP connection-based approach for client management. Especially in MMOGs with a large client management overhead, a pure UDP-based approach can lead to inconsistencies and disconnects due to timeouts or lost packages. Again, the number of packages plays an important role in the design of ENet. Rather than sending only a single byte stream that complicates the delineation of packets, ENet uses connections as multiple, properly sequenced packet streams. To keep the order consistent, ENet provides sequencing for all packets. This approach is again 159
173 focused on the lower protocol level and aims to reduce the overall amount of data sent from one client to another. The game type focus of both applications differs as well: for normal FPS games which are very latency sensitive, this approach supports the games better than the 4MOG middleware. However, in the MMOG area with a growing number of players, the player tracking and TCP connections to each of the clients provides a stable environment which is required for the games. Similarities: Both applications have one major aspect in common. ENet and 4MOG both provide a throttling mechanism to reduce the overall bandwidth required. For ENet, this dynamic throttle responds to deviations from normal network connections to rectify various types of network congestion. Latency spikes in FPS are therefore reduced, making them more playable in situations where a lot of in-game action occurs. 4MOG on the other hand aims to keep the long-term bandwidth relatively constant in order to prevent DOS attacks. Thus, an individual penalty system for the clients is used in case the number of their messages to the server exceeds the limitations Comparison with ZIG Introduction: ZIG is designed as a C++ framework with interfaces to build a multiplayer client-server game on top of it. The framework itself contains two main classes: zigclient_c and zigserver_c both of them can be extended in the game to create the game server and the client class. Therefore, Zig is not a middleware or library from a classical point of view. Rather, it is a class-oriented guideline for the implementation of a client-server gaming application. Differences: The Zig approach uses the UDP protocol with additional functionality, including an option to make the packet transfer reliable (with checksums). In contrast to the Zig approach, 4MOG uses TCP for important data to provide a stable game environment and uses UDP for broadcasting game data with less priority. The network layer, which Zig aims to improve, is mainly the UDP network protocol. The additional functions are a policy management for each of the UDP streams that allow priorities to be set for more important data. Furthermore, a data bundling ensures packets of equal size. In contrast, the 4MOG middleware provides a core set of functions which is required for MMOGs. The 4MOG middleware approaches the game support by offering interfaces to the game engine. In comparison, Zig only 160
174 contains two classes that act as a guideline for the game design. the scope of the two projects differs as well because Zig focuses on improving the network-related aspects (such as latency or bandwidth) without providing additional functionality for the ingame support. Especially for a higher number of participants, the focus on UDP as the network protocol leads to a disadvantage due to possible inconsistencies and disconnects because of packet loss. Similarities: Both applications have the logging mechanism in common. Zig creates an overall log file which stores all network transfer-related information. Again this approach is very detailed, but with a higher number of participants, the logging mechanism needs to be adjusted in order to prevent a data overhead. Generally, any movement and action within the game world can be tracked by using the Zig log file. A similar approach is used by the 4MOG middleware; each client has its own log file which stores the client-related data like connection time, movement and in-game activities. Logging mechanisms in general provide an efficient mechanism for game producers to review in-game activity and to identify potential player misbehaviour Comparison with Raknet Introduction: Raknet is a cross-platform C++ game networking engine. This middleware offers interfaces to game engines; the network functionality is implemented within the middleware. Raknet uses an advanced networking API that provides services based on the Windows systems Winsock. Any other application that also uses Winsock can communicate with the middleware. Differences: Unlike 4MOG, Raknet does not focus on a single game type or game function. In contrast, the approach focuses on additional functionality that can be implemented for any given multiplayer game (like an auto-patcher or in-game chat), although some functionalities offered may not fit with the game type requirements. The auto-patcher option, for instance, is not necessarily required in a SG or a RTS because the number of patches for these genres is relatively low compared to those in the MMOG sector. Raknet also offers an additional voice communication which is implemented in UDP. In contrast, 4MOG focuses on the core functionality since many users do not want an integrated voice chat (compare to Counter-Strike) and because it generates additional overhead. The core functions of 4MOG only focus on the functionality required the 161
175 most for MMOGs like user management. Another major difference is the internal communication of the middleware approaches. Raknet uses a RPC (remote procedure call) design, whereas 4MOG uses a MOM version (message oriented middleware). The differences in the two design methods are described above. Similarities: Both of the approaches use a middleware instead of abstract classes (see Zig) or libraries (see Zoidcom). This decision has several implications, including a hidden internal design (black-box principle) as well as predefined interfaces for the game engine. Also both middleware approaches use TCP for the initial client management and UDP for broadcasting support. Due to their interfaces to the game, both 4MOG and Raknet show similarities in providing additional direct support for the game engine Comparison with GASP Introduction: The GASP middleware project [Pell 2005] aims to improve current multiplayer games with a similar approach. As an open source project, it endeavors to develop a middleware application for mobile multiplayer games, although the focus is slightly different. First of all, the implementation mechanism of the GASP middleware creates sessions for each of the users. This enables the player to choose his/her game at the beginning by requesting necessary data from the server. After receiving an answer, an individual session is created for the user with a session number and further information about the game. From a technical point of view, the main difference between the two concepts is the generalization of a completely game independent structure of the GASP middleware on the one hand and the game-specific middleware framework of the 4MOG approach on the other hand. Differences: The GASP middleware offers interfaces for the players like the opportunity to choose a game. It also supports multiple games, whereas the 4MOG middleware focuses on the MMOG sector. The approach of the 4MOG application offers interfaces to the game engine and the network which the developer can use to reduce the technical implementation efforts of the MMOGSs. As a result of the decision, the GASP middleware needs a central platform representation to support the different games, whereas the 4MOG middleware 162
176 focuses on a lean implementation strategy that can be customized for each of the games. The GASP middleware can be created as a stand-alone application. The 4MOG middleware aims to be integrated into the game, thus becoming a part of it. Generally, it is possible to integrate sub-classes for further common demands like the integration of instance management (for instanced MMOGs), but the final implementation for 4MOG middleware will be customized for any of the applications. This will therefore reduce the overhead of unnecessary functionalities. An example for this are the core set functions, which can be regarded as the least common denominator of technical functionality for MMOGs. As a combination of both methods, one could consider a modular implementation structure, which categorizes each of the features into a specific sub-module. By distributing the game-supporting mechanics to these modules, the publisher could decide whether or not a feature is required for the game and customize the final middleware application. Similarities: There are also similarities in the design of the both middleware applications. The GASP middleware is also implemented as a message oriented application. This decision reflects the importance to keep the network traffic as small as possible to support a large number of players. As a conclusion: the main difference between the two applications is their functionality. While the 4MOG middleware aims to solve a specific problem (supporting the developers), the GASP middleware has a much larger scope. Nevertheless, the two applications have the MOM implementation in common in order to reduce network overhead. The comparison of both middleware applications does not promote one system over the other; their usage clearly depends on the scenario. For example: the typical scenario that promotes 4MOG middleware over GASP middleware is the design of a specific MMOG in a smaller game company. That is because the 4MOG middleware offers explicit functionalities for the technical aspects of game creation. For this scenario, the 4MOG middleware would therefore be superior since the GASP functionality aims to support different types of games or even a game collection, which is not needed for a single MMOG. An interface for multiple games is not required if only one game needs to be created. 163
177 In contrast to this, other scenarios such as the design of an online game collection would clearly promote the GASP middleware because it offers support for multiple game types and focuses on the interfaces for a game selection. The 4MOG middleware offers interfaces for the core functions (such as connection, communication, etc.). However, if the usage case aims to create a bundle of casual arcade games, a chat might not be required. Therefore, the GASP middleware suits this usage case better Overview of the comparison This section gives an overview of the different middleware and library approaches. It summarizes the main similarities and differences in a table. Some aspects of these solutions, however, cannot be compared like Zoidcom for example because the advantage of the additional functionality strictly depends on the situation. For some games, the middleware might offer considerable support because all of the functions are mandatory, wherease other applications might not benefit from it at all.
178 165 Table 6.1. Overview of the different middleware and library approaches to support computer games network functionalities Name Game type Protocol Approach Functions Zoidcom FPS& space UDP Library Player tracking, UDP enhancement ENet FPS UDP Library Streams, UDP enhancements, throttling ZIG All UDP 2 classes Logging system, UDP enhancements Raknet All Winsock & UDP Middleware Additional functionality, auto-patcher, login, in-game chat GASP All TCP/UDP Middleware Additional functions, game lobby, user management 4MOG MMOG TCP/UDP Middleware Core functions for development, throttling mechanism, logging Testbed GASP, Zoidcom, ENet, Raknet, ZIG and the 4MOG middleware cannot be compared directly with regard to technology since all of these applications have a different focus. In contrast, this section contains a testbed for the 4MOG middleware application. It is vital to pinpoint that the MMOG scenario does not have the same problems as mobile gaming. Latency is also an important issue, however, especially with a growing number of players, scalability is still the most important issue for MMOGs. With only a single server (which is the bottleneck in the network design), one
179 important aspect for MMOGs is the amount of network traffic which is sent/received by the server. As mentioned earlier, one of the options to cheat in MMOGs is to abuse the number of packages that one player can send. Therefore, the middleware needs to be robust against client spamming behaviour. The testbed itself is independent from the mobile environment and uses a local area network for the connection. Nine different computers are used in the local area network, each of them with following configuration: Windows XP workstation, Pentium 3GHz processor, 1GB RAM and a 100Mbit/s network adapter. Lab1 is used to run the server version of the 4MOG middleware, whereas Lab2 Lab9 run 10 4MOG clients each. Therefore, the final testbed contains 80 different clients that are connected to the server, as shown in Figure 6.5. The server simulates a two-dimensional game world with a size of 200x200 fields. Each of the given 80 clients is randomly placed in one of them. During the test scenario, every player moves randomly with an individual speed. After a player has performed he/her movement, the other players in range will receive a notification about the new position. Moreover, the clients are divided into four different player types with their own spamming behaviour. 166
180 Figure 6.5. Illustration of the testbed: Group1 is configured to be the very strong spamming group, group 2 sends a high number of packages, group 3 is a normal number and group 4 reveals low spamming behaviour 167 Additionally, a percentage value is responsible for the client s probability to randomly change its behaviour, which entails either a stronger or less stronger spam. Although the underlying player model is kept relatively simple, both reactions can occur in actual reality. Either a player reduces the overall number of messages and slows down or he/she keeps on spamming in??defiance??. The maximum number of packets is capped to 20 per second: the first computer of each group (Lab2, 4, 6, 8) always contains the solid players who rarely change their behaviour. Therefore, the rate to adopt a new spamming behaviour (randomly between 1 and 20 packets per second) is set to 33%, which signifies a 67% probability of maintaining the old rate. The second computer of each group (Lab 3, 5, 7, 9) is designed to adopt new behaviours with a 66% probability. In fact, after each cycle (for the testbed this is 1 minute) the spamming behaviour is recalculated, hence regular spammers tend to fall back to their initial rates. The length of the cycles can vary, for this testbed 1minute gives the clients enough time to adjust their behaviour before falling back into the initial spamming strategy. The results of the testbed are discussed in the next chapter. Table 6.2. Group setup of the testbed Group Number (with related clients) Group 1 (Lab2,3) Group 2 (Lab4,5) Group 3 (Lab6,7) Group 4 (Lab8,9) Spam behaviour (package per second) Very high (12 per sec) High (9 per sec) Average (6 per sec) Low (3 per sec)
181 6.4 Summary 168 This chapter summarizes the advantages and disadvantages of using a middleware application. The section covers three main aspects of middleware creation: the definition of requirements, the implementation and the validation. Each of them is described individually. Furthermore, the UML diagram of the core classes is explained as well as the resulting testbed with 80 clients and different spamming strategies. For further information, Chapter 7 illustrates the results in-depth and compares them with related attempts.
182 Experimental Results By far the best proof is experience, Sir Francis Bacon. This chapter analyzes the statistical results of the player behaviour surveys in detail. With regard to other surveys, the results and statistical correlations are evaluated. Likewise, the most important findings from the virtual fragmentation survey are discussed. Furthermore, the testbed results for the mobile lobby combined with the results of the follow-up survey from chapter 5 are analyzed. Moreover, the 4MOG testbed of the middleware prototype is evaluated and compared with similar software approaches. Finally, the contribution of each of the three main approaches is evaluated by comparing them to the status of the problematic fields: player behaviour, mobile gaming and massive multiplayer gaming. 7.1 Statistical Analysis of Player Behaviour The large numbers of replies from the online questionnaire exceed the expectations. Overall, more than 30,000 users participated in the survey; half of them answered the questionnaire distribution of online gaming behaviour., around 1,300 users from the FPS section, 1,100 RTS users and only 197 SG players. Another important aspect is the distribution type of the data pool; therefore the Jarque-Bera is used in order to prove the deviation from normality. Before taking a closer look at the general results, one should first evaluate the game types. The survey is individualized for each of the four main game types: FPS, RTS, RPG and SG. Each of the sections in the survey contains a common set of questions about the user activities focused on the game (such as forum activities, web pages, communication tools and in-game videos). Furthermore, all of them include game type-related questions about expectations and motivation. For example: an analysis of the computer gaming priority in the users daily routines.
183 The idea behind the survey is to analyze the influencing factors for the time that players spend on their game(s). Furthermore, the influence of demographic values (age, gender, leisure time, etc.) on the overall game time needs to be analyzed. Beyond that, each section contains an analysis of the different competition types. From previous interviews/surveys [Fritsch ] it has been determined that users tend to answer more inaccurately with regard to higher numbers. For instance, it is hard to estimate the exact number of hours that someone worked last year. Thus, the number of hours per day for game time and leisure time is capped to a maximum of 8+ hours. The set of users that chose the highest possible answer for game time includes all users who play eight or more hours a day. This classification has been performed in the survey for two main reasons: firstly, the users are not motivated to over-estimate their own game time. In a pre-survey without the limitation, many users stated that they play 20 to 24 hours a day (each day). For rare exceptions such a time might hold true (examples of hardcore gaming are often found in the MMOG sector), but in many cases, users had difficulties in correctly estimating their average game time per day. The second important reason for the classification of 8+ hours is the purpose of the survey. The main objective is to evaluate whether or not a player can be classified as a hardcore user. Since the definition of hardcore gaming depends on the viewpoint, the borderline between casual and hardcore gaming might vary. With regard to the average working time for most people (which is about 40 hours per week in Europe), this survey defines that a hardcore player invests at least that much time in gaming. The maximum possible game time per week is 56 hours (7 days * 8 hours), which already exceeds the average working time by far. However, one cannot assume that this maximum number accurately reflects the overall limit of game time per week. In fact, the data pool shows that a large percentage of players reach the 56 hour limit, which means they play at least 56 hours a week. In order to analyze the real maximum game time, individual interviews were held with players from top clans of the FPS and RTS sectors. To understand the gaming behaviour, one must observe the demographic values first. In our observation, the survey focuses on current online gamers from the FPS, RTS, RPG and SG sectors only. Therefore, as indicated in Section 4, the overall 170
184 demographic values differ slightly from those in [Thee 2007]. The data pool reveals certain similarities such as the marital status and gender. A large majority of the players in our sample are single; FPS: 93.0%, RTS: 97.8% and RPG: 89.9%. The only exception in this context is the sports games sector; only 68.4% of the players in the sample are single. The other possible options are married, divorced and widowed; all of them show a very small number of matches (except married in the sports game sector). Furthermore, the gender distribution also shows similarities. The rate of males in the sample according to game types is: FPS: 97.8%, SG 95.3%, RTS: 99.2% and RPG: 92.3%. Our sample accurately reflects the distribution of the online gamer population. Especially in online games, the ratio of female players (according to [Bliz]) is relatively low. Exceptions occur (like The Sims [Sims]); however, for the majority of the current best-selling online games from the FPS, RTS, RPG and SG sector, nearly all players are male. 171 Figure 7.1. Age distribution among the different game types: From upper left to bottom right: FPS, SG, RTS and RPG There are also differences in demographic values between the game types. The average age differs significantly among the four types. Figure 7.1 shows four
185 different box plots, where the leftmost line indicates the x0 quantile, a representation of the lowest value. Analogously, the rightmost line is the x1 quantile, a representation of the highest value of the data set (circles on the right-hand side are single values that can statically be regarded as escapees). An analysis of the data pool shows more or less consistent values of x0, the youngest participants are always around 10 to 12 years old. An explanation for that is either the value of the technical equipment and/or the content of the games. Differences between game types occur in the area of the x0.25 and the x0.75 quantile (the x0.25 quantile describes the number of years under which 25% of the players are; x0.75 accordingly describes the 75% borderline). The box between the x0.25 and the x0.75 quantile contains the 50% average aged players (players who are older than 25% of the users and who are younger than 25% of the users). The x0.5 quantile is represented by the line inside the box; this quantile represents the median of the players age. As one can see, the FPS sector in the sample has a median age of 18.1 years with a sigma (standard deviation) of 5.7. The peak age is around 15 to 18 years, while the maximum age (except for a few insignificant outliers) is 27 years. RTS games show a similar distribution, hence keeping this in mind both game types feature a solo and PvP competition. Also the pay-to-play (monthly fees) method from most MMORPGs tends to be a reasonable factor for younger gamers to stay with the FPS and RTS sector where most games only have the initial purchase cost. On the other hand, RPGs in our sample show a higher affinity to a mature player community. The arithmetic average age is years with a sigma of 6.2. Similar to that distribution is the SG box plot; although it is distributed more uniformly. At least RPGs feature a variety of team challenges and a strong focus on PvE; both are indicators for the significant differences. Compared to other survey results, the age and gender distribution shows significant differences. In [Thee 2007] the overall US game market is evaluated. Their findings indicate that: (1) The average game player is 35 years old and has been playing games for 12 years. 172
186 (2) The average age of the most frequent game buyer is 40 years old. In 2008, 96 percent of computer game buyers and 86 percent of console game buyers were over the age of 18. And, 83% of game players under the age of 18 report that they receive their parents' permission when renting or buying games, and 94% say their parents are present when they buy games. These differences in the survey results are based on different samples because [Thee 2007] focuses on the US market and includes all game genres (also casual games, browser games, etc.). The participants were selected due to their buying behaviour and were contacted directly. The games purchased do not necessarily contain a multiplayer option or any form of online interaction between the players. As shown, the average age in the sample of [Thee 2007] is 35 years, whereas the distribution of online gaming behaviour reveals an average age of 18.1 to 22.1 years, depending on the game type. This large gap is based on two circumstances: the more mature players with high gaming experience (12 years) tend to play casual, and single player games rather than online games many players stay in contact with game concepts that they are familiar with One should keep in mind that the Internet and the network aspect for computer games became popular during the 1990s, and current blockbusters (like MMOGs) started in Therefore, the older player generation is familiar with single player and hot-seat game concepts. One possible explanation for this gap is that older players prefer known game concepts over new game concepts. Therefore, the number of competitive online games in this age group is low. This evidence is further underpinned by [Casu 2006], one of the main statements in the report is: Casual games are replacing television viewing as an important stress reliever after work and during lunch hours. In fact, [Casu 2006] reveals that the number of older players (35+) in this segment comes to 62%, most of them only play short sessions, which leads to the next aspect. The amount of leisure time available is lower for the mature player group, therefore game preferences for these players differ from current competitive online games. These players prefer simple game mechanisms, an easy competition with an AI and 173
187 the opportunity to switch the game off at any time instead of competing intensively with other players. (3) Forty percent of all game players are women. In fact, women over the age of 18 represent a significantly greater portion of the game playing population (33 percent) than boys aged 17 or younger (18 percent). The argumentation for the gender distribution likewise compares the distribution of online game behaviour survey with the survey results from [Casu 2006] and [Thee 2007]. Again, a significant difference in the number of female players can be found. Since 51% of the casual players from the sample of [Casu 2006] are female, this shows a clear difference in the gaming interest. Women in any age group show significantly less interest in in-game mechanisms or competition intensive online games. Thus, the sample for the distribution of online game behaviour only contains 2.8% female players. This evaluation of the age distribution among game types leads to an analysis of the total game time per week. As hardcore players are mainly categorized by being stubbornly persistent in playing the same game with far above average interest than other players, this also increases their average game time [Frit 2006]. By analyzing the correlation between high game time and nationality in [Frit 2006] one can observe that there are countries with a significantly higher average game time. Sweden, Norway, the UK and the Netherlands score explicitly higher than Poland or Switzerland. In order to substantiate this difference, a one-way ANOVA model was used. The analysis of variance (ANOVA) describes a collection of statistical models in which the variance observed is partitioned into components (explanatory variables). There are certain assumptions for the ANOVA which are necessary in order to use the ANOVA. The assumptions are (1) the independence of cases, (2) normal distribution of the data and (3) equal variance between the sub-groups. In general, the F-Test and the T-Test are methods related to the ANOVA model. Depending on the underlying data and the number of groups that one wants to compare, either the F-Test or T-Test must be used. The T-Test directly compares two sub-groups and decides whether or not a statistically significant difference exists. The F-Test on the other hand compares multiple groups for a potential difference. By 174
188 doing so, the F-Test indicates whether at least one sub-group shows statistically significant differences; however, it does not indicate which sub-group is different. For the statistical analysis of the demographic data and the hypothesis in the following sections, the assumptions for the tests hold true. For each case the independence of the variables exists, no influence between two questions was measured. Furthermore, the variables are confirmed to be normally distributed due to the Jaque-Bera test. Finally, the variances of the sub-groups are similar, in fact, for most of the sub-groups they are nearly the same (due to the large size of the sample). The nationality is suggested to be an influencing variable for the game time; therefore the sample is clustered into sub-groups by the attribute nationality. Each of the countries selected had at least n=10 participants in it, therefore the degree of freedom for the F-Test is at least 9 (it is effectively much higher when comparing two of the major countries). The results of the F-Test for several sub-groups indicate that the F value is much higher than F.05 (9,9) = 3.388, therefore one can reject the null hypothesis. In other words, the average game time is influenced by the nationality. The countries with a higher average game time can be regarded as game-affine countries. One possible explanation for this behaviour could be the difference in the national connectivity standard. As an example: Scandinavian countries have several providers that offer explicit gaming flat rates (low bandwidth compared to other DSL connections, but no error correction and therefore a latency of around 20 ms for most game servers). This finding indicates that the nationality is also an influencing factor for the game behaviour. Another interesting approach is the language, because all of the high scoring countries (except for the Netherlands) have native languages that are limited to their region, whereas English is their most important foreign language. Most online games have a majority of English-speaking servers. Poland and Switzerland also have a strong relation to the German language. Especially international MMOG retailers like SOE and EA often initially release their games in English. Some best-selling games (like Everquest or Linerage) have never had a translated version. 175
189 Hypothesis 1: 176 One of the major aspects in the analysis of the game time is the potential influence of the different game types. The relevant null-hypothesis is: H0 1 : No difference in the average game time per week between the game types exists. If the overall game time is influenced by the game type, the null-hypothesis needs to be rejected. It can only be rejected if a statistically significant difference between the game types can be identified. The statistical analysis makes it necessary to cluster the sample into sub-groups with the same game type. The smallest sub-group has a size of n=197 entries (SG players), therefore the degree of freedom for the F-Test is 196. Since the remaining sub-clusters have more than m=1,000 subjects in them, the effect of the critical value for the F-Test becomes relatively small, therefore the F.05 (197, 1000) is taken. For larger values of n, the critical value of the F test becomes smaller. With an α=0.05 the critical value F.05 (197, 1000) = 1.16 (smallest value is reached for F.05 (, ) = 1). The F-Test for the sub-groups indicates an F-value of 1.9, which is significantly higher than the critical value. Thus, the null-hypothesis can be rejected. The result of the F-Test can be interpreted as follows: a significant difference between the subgroups exists, although the F-Test alone does not indicate which of the sub-groups differ. Further T-Tests (direct comparison of two sub-groups) underscored the finding. As a result, the participants average game time is influenced by their game type. When considering the average game time of each sub-group cluster, both FPS and RTS reveal a relatively similar game time as opposed to SG and RPG. Based on confidence intervals with α=0.05, the players from the FPS game type generally tend to invest 15.2 x 17.1 hours per week on average in gaming. The respective RTS average hours of game time per week interval is (16.1; 18.9). Both game types also feature a group of players with significantly more time than that mentioned above (20% in both game types scored over 40 hours per week). On average, the SG community spends significantly less time on gaming: the confidence interval for the average hours of game time per week is (10.2; 11.8),
190 which is the lowest score among the game types. Again, approximately 20% of the player base scores noticeably higher than that. The RPG player community has the most outstanding score, the interval of this sub-group for their average hours of game time per week is (32.1; 33.2). By taking a closer look at the distribution, one can observe that more than 40% of all players tend to play more than 40 hours a week, several of them even reached the 56 hour borderline. This large number of players from the RPG sector with 40+ hours a week is an interesting point for a deeper evaluation of the game time. Hypothesis 2: H0 2 : The relative gaming time (game time divided by available leisure time) is not influenced by demographic factors or the game type. The correlation between game time and different game types has already been discussed above. To further analyze differences in game time among the game types, a new key performance indicator (KPI) has been created. The relative game time equals the total game time per week divided by the total leisure time per week. This number can range from 0 to 1, where 0 equals no time of the available leisure time is spent on gaming and 1 indicates that all of the available leisure time is spent on computer gaming. Again, the score of the sub-group RTS players and FPS players is relatively equal. The average relative game time confidence interval for the RTS sector is (0.41; 0.49). Accordingly, the average related game time confidence interval for the FPS sector is (0.47; 0.55). This signifies that for any given sample of the FPS sub-group with a 95% probability, their average game time per week is 0.47 to 0.55 (which equals 47% to 55% of the available leisure time). The SG sub-group once again scores significantly lower with a confidence interval of (0.24; 0.33) and the RPG sub-group scores significantly higher compared to FPS and RTS with a confidence interval of (0.75; 0.79). In order to compare the different game types, a F-Test with all of the sub-groups is used. The F-value of 2.55 is significantly higher than the critical value of F.05 (197, 177
191 1000) = The null-hypothesis can therefore be rejected because a significant impact on the relative game time exists due to the game types. By comparing the different confidence intervals, the most significant difference can be found between the SG sub-group and the RPG sub-group. These confidence intervals show a major gap, which leads to the conclusion that the null-hypothesis can be rejected because the game type has a statistically significant influence on the relative game time. Hypothesis 3: H0 3 : The overall gaming time (hours per week invested in gaming) is not influenced by the players attitude towards real-life events (family, real world events, job). 178 The concept of different content in each of the game types leads to the game-related activities. The analysis of the overall game time per week also includes possible relations with real-life events. If a correlation between the overall game time per week and these real-life events exists, then hardcore players would not only demonstrate a similar behaviour in-game, but they would also share a common attitude towards real world events. The survey includes a common set of five real world-related questions which are equally applicable for all game types. These questions are: (1) Would you eat at the computer in order to not miss out on an in-game event? (2) Is the game the main topic in your conversations with friends? (3) Do you plan your day around in-game activities? (4) Do you hide your amount of game time in front of your family/friends? (5) Would you neglect your job in order to play more? If a correlation between in-game attitude and real world events exists, then the nullhypotheses must be rejected. Statistically, the evaluation starts by clustering the whole sample into sub-groups. For this survey, six sub-groups were chosen according to the number of real-life questions answered positively. A positive correlation would indicate: the more positive answers to real-life questions, the higher the overall game time. The smallest sub-group is the sub-group with 0
192 positive answers to these questions with overall n=121 members, therefore for the F- Test the degree of freedom is 120. The F-Test compares the average overall game time of the six sub-groups with each other. The critical value for F.05 (120,500) = 1.25, the most significant F value was reached between the sub-group with 0 positive answers and the sub-group with 5 positive answers. With a F value of 3.1 > F.05 (120,500) = 1.25 the null-hypothesis can be rejected. Most of the other F-Tests also indicated a correlation between the number of positive real world answers and the overall game time per week. Figure 7.2 illustrates the percentage of positive answers divided by game types. Again, the RPG player community scored significantly higher than the others. For instance more than 67% of all RPG players eat at the computer, 75.90% plan their day around the game and 81.00% would neglect their job to play more. 179 Activities divided by game-types 90,00% 80,00% 70,00% 60,00% 50,00% 40,00% 30,00% FPS SG RTS RPG 20,00% 10,00% 0,00% Eating Talking Day-Planing Family Job Figure 7.2. Game-related activities divided among different game types. Each bar on the Y-axis equals 10% of the users (belonging to the relevant game type) in the survey. The percentage of positive answers is shown in the diagram The only mentionable difference is the low number of players in the FPS and RTS genre, who would hide their game time in front of their family and friends (only 22.50% and 17.50%). Another mentionable difference in the three game types FPS,
193 RTS and SG is a high percentage of SG players who would hide their amount of gaming in front of their friends and family. Table 7.1 concludes the context discussed by looking at the percentage of players who answered 4 out of 5/5 out of 5 questions with yes. The section 4 out of 5 already contains all the players who answered 5 out of 5 questions. All game types except for the RPG sector feature an approximately 20% player base of hardcore gamers (similar to the 20% mentioned for game time observations). Admittedly, the rate of players with 5 out of 5 positive answers is relatively small (this is due to the normal distribution). 180 Table 7.1. Measurement of percentage of users with 5 out of 5 and 4 out of 5 questions answered positively 5 out of 5 4 out of 5 FPS 9.28% 22.39% SG 8.33 % % RTS 6.20 % % RPG % %
194 Statistical Analysis of Virtual Fragmentation Overall, more than 14,000 users participated in the virtual fragmentation survey. However, the number of valid data sets is only 5,800; most of them were excluded from the statistical evaluation because they were incomplete. Compared to the distribution of online game behavior survey, the number of potential multiple answers by a single participant (repeated answers) and random answers (white noise) were lower. This section briefly introduces the most important survey results. A more detailed version of the results can be found in [Frits ]. Demographic values: As already indicated in section 4.2, the user group in our survey is not homogeneous. The gender distribution clearly indicates more male users; the confidence interval with α=.05 for the percentage of male players is (88.4; 89.3). This indicates that with a probability of 95%, any random sub-group in our sample will have 88.4%-89.3% male participants on average. Compared to our analysis of hardcore gaming behavior [Frit 2006] this number is surprisingly high. The marital status indicates similar results as in [Frit 2006], most of the users were single 86% (highly correlating with the age, nearly 98% of the players under 25 were solo); 12.6% were married, 1.1% divorced and 0.3% widowed. When contemplating the sample s distribution, the user group for virtual fragmentation was distributed in a typical manner with high values in high school and the university, and low values in worker and no professional areas. A relatively low number of 7.2% are unemployed, 4.0% worker/apprenticeship, 38.8% high school and 50.0% college students. This distribution is illustrated in Figure 9.23 (see Appendix). Hypothesis 4: The first step in analyzing the gap between real world and virtual behavior is to compare the MOS values with each of the five attributes. The underlying hypothesis is: H0 4 : No difference between average MOS values for real world behaviour and average MOS values for virtual behaviour exists.
195 In order to reject this null-hypothesis, at least one contrary example must be found. Therefore, the attribute of conscientiousness is evaluated in detail. A high value in this attribute includes behaviour that is thoughtful, goal-driven, organized and mindful with regard to details. Figure 7.3 illustrates the difference between the average mean opinion score of virtual conscientiousness and real world conscientiousness. Both values are based on the respective questions (questions from the conscientiousness inventory). 182 Fragmentation Conscientiousness mean opinion score 4,50 4,00 3,50 3,00 2,50 2,00 1,50 1,00 0,50 0,00 < age in years Virtual Real Figure 7.3. Virtual fragmentation of the attribute conscientiousness ; the MOS scores marked in red range from 1 to 5. The virtual conscientiousness is higher for any age group, however, especially the younger players under 20 reveal a larger gap. A difference of nearly 1.0 (average virtual C = 4.0 and average real C = 3.0) clearly shows different behaviour. The real world conscientiousness shows a slightly positive slope towards age; mature users tend to be more goal-oriented and mindful. In contrast, especially young players show a very high score in virtual conscientiousness, thus indicating a well-organized and goal-oriented online behaviour. The statistical analysis of this gap includes a one-way ANOVA (requirements normal distribution, independence is given). The sample size is n= 5,801, therefore the degree of freedom is 5,800. Since only two sub-groups are compared with each other, the two-sided T-Test is used for this analysis. With an α=.05 the respective
196 critical value T.05 (5800,5800) = For this analysis, the average answer values for real world and virtual world conscientiousness are compared. The T value of 2.57 > T.05 (5.800, 5,800) = 1.96 ranges in the critical area, which leads to the conclusion that the null-hypothesis can be rejected. A significant difference between real world and virtual world values exists, further T-Tests of the other four attributes as well as the overall gap underscore this finding. Hypothesis 5: The second important hypothesis describes the further influencing factors for the virtual fragmentation effect. In order to prove an influence of these factors, the nullhypothesis must be rejected: H0 5 : Further factors (such as age, gender, educational level and game type) do not have a significant influence on the level of virtual fragmentation (size of the gap between virtual and real world behaviour). Again, at least one statistically significant contrary example must be found to reject the null-hypothesis. The data for age distribution provides an excellent influencing factor for further analysis. The age distribution within the sample is not distributed equally. The x0 quantile (youngest participant) is 11 years, the median (x0.5 quantile) is 21.2 years and both the x0.25 and x0.75 quantile show a close age distribution around the median. This means that 50% of the survey users are between 16 and 25 years of age. This age distribution is illustrated in Figure
197 184 Figure 7.4. Box plot of age distribution in the survey virtual fragmentation As an example, the differences between real world and virtual world mean opinion scores for the attribute agreeableness are evaluated. A high value indicates attributes like trust, altruism, kindness and affection. Figure 9.24 illustrates the findings divided among the age groups. For this test, each of the attributes is clustered into sub-groups by age. The youngest participants are around 10 years of age, the oldest (except for outliers are 40 years of age). A clustering with five years per cluster creates eight sub-groups. Afterwards, the average MOS scores for the real world and virtual world attributes are compared by means of a one-way ANOVA test. The most significant result was determined for the attribute of agreeableness. Overall, the smallest sub-group is the group of 36 to 40 years of age with an overall number of 112 subjects, thus the degree of freedom is 111. The younger sub-groups (10 to 15 years and 16 to 20 years of age) have a T value of 2.94 and 3.12 compared to the critical value T.05 (110,110) = 1.98 which shows a significant difference between real world and virtual world average mean opinion scores. In contrast, the middle age sub-groups (26 to 30 years, 31 to 35 years and 41 to 45 years of age) show T values with no significant difference between the average real world and virtual world mean opinion scores. Both results together show that the younger age groups differ significantly in terms of statistics, whereas the middle age groups do not differ. This leads to the
198 conclusion that the initial null-hypothesis can be rejected because a contrary example has been identified. The evaluation of the other four attributes further underscores the influence of age on the size of the gap between average real world and virtual world mean opinion scores Results of the Mobile Lobby Survey More than 1,100 users participated in the underlying online survey, and 1,080 of them answered all ten questions. The questionnaire also included a small demographic part (location, gender, age) for the further analysis. Moreover, the gathered results underpin important aspects of the current mobile phone gaming situation: The data show that a majority of over 90% would like to play mobile phone games with their friends; although only 42% (36% women, 45% men) would consider playing the same games with random people; Figure 7.3 summarizes this aspect. The statistical analysis shows a minor correlation (0.51) between gender and preference to play mobile phone games with friends. Women tend to prefer not playing these games with strangers even more so than men. Hence, the game design should seriously take into account that random matching obviously does not match the users preferences. Game preference results show a more surprising outcome. The probe shows a strong correlation between location and favorites in mobile phone games. Most participants in all countries prefer arcade games (31.5% in Sweden up to 64% in the UK). Overall, the other game types (RTS, FPS, action and puzzle) are practically identical with around 15% each. However, there is a tremendous variance with regard to the countries. One possible explanation for the popularity of arcade games is their very simple game control mechanisms. Nevertheless, only 10% of the users would pay to play mobile phone games. The average mean opinion score of taking mobile games seriously is 2.1 (1= definitely not serious, 5= very serious), which further reflects the casual nature of mobile games. Both facts together show that location, gender and age independent (only very minor correlation has been determined) players are not willing to pay or take the current mobile phone games seriously. The main objective appears to be playing quickly with friends.
199 Current mobile games on next generation handhelds feature better graphical support like 3D rendering on the Sony PSP or shading and pseudo 3D design on the Nintendo DS. If one compares the mean opinion scores of graphic popularity, it turns out that the handhelds (MOS [mean opinion score] overall 3.78) score is significantly higher than the score for mobile phones (MOS overall 2.33). This means that the average player is satisfied with the graphical performance on handhelds, whereas on average, players tend to dislike them on mobile phones. Additionally, the data indicates a strong linear negative correlation (0.77) between age and the difference. Mature players perceive less difference within the two devices. As a result, one can conclude that shading and layer usage would further increase the acceptance of current mobile phone games. The time required for a complete game setup was rated with a mean opinion score from 1 (very unimportant) to 5 (very important). With an overall score of 4.43, most players have a strong focus on a fast game setup. Nevertheless, the preferences varied between countries, ranging from 3.89 in Italy to 4.90 in Germany. This noticeable result leads to the software solution of a mobile gaming lobby in order to decrease the search and setup time, hence the matching time is drastically reduced and it is more likely that further opponents can be found Testbed Results of the 4MOG Middleware One of the main problems in the MMOG middleware sector is the reduction of overall bandwidth because of the servers bottleneck attribute. With a growing number of players, the bottleneck results in a delayed answer. If the server is massively overloaded, then the worst case scenario is a shutdown. Therefore, the 4MOG approach to reduce the number of packets includes a simple penalty system. The idea is to permit the users to attack the server with brute force in order to reboot it. If a user keeps on spamming over a certain period, then he/she receives a penalty. The longer this user continues to ignore the penalty, the tougher the consequences will be. With a rising penalty level, the users maximum number of packages that one can send decreases. However, if the target changes his/her behaviour, then the penalty level will decrease again until it reaches the initial status.
200 As an indicator for over-proportional bandwidth consumption, the testbed uses a certain number of messages which a player is allowed to send per minute. If the user shows an unacceptable behaviour for more than 50% of the time, then he/she receives a higher penalty level. The first penalty level slightly reduces the number of packages allowed, whereas the reduction of possible packages also increases with an increasing penalty level. If a user continues to send too many packages, then the penalty level increases to its maximum which throttles the user. The middleware system keeps track of the number of messages each second and compares it to the limitation. As an example: if a user sends more than ten messages per second over 30 times in a minute (more than 50% of the time) then he/she receives a penalty level, which reduces the maximum data rate. If the player continues to send the maximum data allowed, it will lead to the next penalty level which reduces the data rate even more. With regard to the middleware s other functionality, the penalty level system reflects the focus of the prototype implementation. The purpose of the testbed is to ensure that the message communication is implemented and that the penalty system works as intended. The additional functionalities (like player tracking, object movement, etc.) have not been fully implemented in the prototype yet since the initial testbed focuses on just one function of the middleware: network communication between server and client. The penalty level system forces users to adopt a certain behaviour in order to reduce their individual communication behaviour with the server. One should take into account that the design of the penalty level must be individualized for each of the MMOGs. The objective of this approach is to ensure that a normal player in the game world will not receive a penalty level, whereas players who use brute force mechanisms to overload the server should receive penalty levels. A static penalty system is used for the testbed, which does not take the situation into account. For example: if a challenging fight is ongoing, users tend to take more action and thus to send more packages. Table 7.2 illustrates the different penalty levels and the relevant restrictions for further bandwidth consumption. As one can see, the first penalty level reduces the maximum number of packages for the client to 10 per second. With an increasing penalty level, the number of packages decreases even further. The 187
201 examples of the testbed do not refer to a certain MMOG; the numbers are used to test the functionality of the penalty level system. 188 Table 7.5. Penalty level system of the 4MOG middleware testbed Penalty level Level 1 Level 2 Level 3 Level 4 Maximum number of packages 10 per sec / 30 times per min 8 per sec / 30 times per min 6 per sec / 30 times per min 4 per sec / 30 times per min The numbers are based on the technical data of Half Life [Half] and the technical report about the network structure of this game [Hend 2001]. According to the description of the Half Life server, the average number of packages from a single client per second is between four and six. These numbers can be transferred to a MMOG scenario, since the movement and interaction with the game from a client s perspective is relatively similar. Other game genres also indicate similar numbers. For example: top players from the RTS genre have around APM (actions per minute), which approximate four to five actions per second. Since not every action requires communication with the server (for example, units are selected locally), the resulting number of communications with the server is even lower. As expected, the clients in group one (strong spammers) received the highest penalty level on average during the entire timeframe. As illustrated in Figure 7.6, the penalty level for all players starts at 0, whereas most members from group one already reach penalty level 2 after only two minutes. Other groups score significantly lower both on average and over the long run. Especially the group of Lab 2, with less probability of adopting a new behaviour and with high initial bandwidth consumption, almost always reaches the highest penalty level very quickly. The figure also encompasses an interesting observation on the long-term trend of groups 2 and 3. Usually group 3 is expected to reach a high level faster, but only over the long run is group 3 capable of scoring higher on average compared to group 2. The test itself was conducted three times in order to ensure necessary reliability. An intelligent client system that
202 actually reacts to the given penalty level would probably construe other results; nevertheless, focus of the testbed relies on prototype s functionality and not on the integration of next generation AI. 189 Average level of the groups 3 2,5 2 Level 1,5 1 0,5 0 0 min 2 min 4 min 6 min Figure 7.6. Illustration of the average penalty level for each group. The colors are: blue equals group 1, green equals group 2, red equals group 3 and yellow equals group 4 Another aspect of the testbed is the tracking of average RTT (round-trip times) and the usage of AOI (area of interest) management to significantly reduce overall latency. Therefore, the 4MOG middleware tracks the RTT for every client by using regular pings from the client and the logging system of Gamestate. The area of interest (AOI or ROI for region of interest) concept is a common design pattern in computer games today. The main idea is to limit the information that each client receives. Therefore, only events that can be seen directly by a client are submitted. If a virtual object obscures the event, then the player does not necessarily need to receive the game information. This method enables the number of packages for each client to be reduced, hence also decreasing overall network traffic. The test aims to integrate a commonly used technique from the FPS game design into the prototype to further reduce the overall number of packages. The AOI value defines the number of fields (geometrically a square) from the current player position that is observed. If an event occurs outside of the area of interest, then the player will
203 not receive any information about it. Figure 7.7 features a simple example of an AOI field and the game world. The lower the AOI value, the lower the overall number of packages that are received. In a game world with a total size of 200x200 game fields, the AOI value for the testbed reduces the fields step-wise down to 180, 150, 120, 90, 60 and 30. One should keep in mind that an area of interest of 30 still covers a significant range compared to the whole game world (30 fields in each direction equal a width 60 fields and a number of 3,600 fields overall). By covering 3,600 fields (AOI range 30) out of 40,000 fields (200x200 game fields), the client still receives information about 9% of the complete game field. In order to illustrate the size of this area of interest: current MMORPGs feature very large persistent online worlds. Everquest [Ever], for example, contains far more than 250 different in-game zones and the view of the player therefore never exceeds even 0.1% of the entire online world. For a MMOG, the AOI concept can be implemented even more strictly. As the game world is very large, the user will only need to overview a very limited part of it. 190 Figure 7.7. Diagram of the game field: each of the cells represents a single game field. The AOI is indicated as a rectangle around the player s position
204 191 RTT with different AOIs RTT in ms AOI = 180 AOI = 150 AOI = 120 AOI = 90 AOI = 60 AOI = 30 Figure 7.8. Diagram of the average RTT with decreasing AOI values and ensuing round-trip times As illustrated in Figure 7.8, one can see that the overall RTT is reduced drastically as soon as the AOI value reaches 90. That is because players in the center no longer receive information about the entire game field. Even with a fairly high AOI rate of 30 to 60, the RTT times are 200+ times lower than compared to normal broadcasting methods. In concluding the analysis, the testbed shows that the penalty system is capable of reducing the bandwidth by tracking each player. Supported by the middleware prototype and the Gamestate logging mechanism, a gaming provider could define certain rules for different situations and thus offer each player (depending on the behaviour) fair treatment. Furthermore, once an AOI system has been implemented, the testbed shows that the average RTT time (also tracked by using the logging system of the middleware) is reduced significantly by forwarding the necessary messages only. Both of them are a first test regarding scalability, which is a significant aspect for every MMOG.
205 Comparison with the Related Work In order to illustrate the contribution of the individual approaches, Table 7.3 includes an overview of the related work introduced and the approaches in this thesis. All of them are evaluated with regard to the six main parameters: scalability, mobility, reusability, quality of service, user behaviour and hardware expenditure. Chapter 3.6 describes each of the parameters in detail. The experimental results in this section cover different aspects of the research. First of all, the statistical analysis of player behaviour aims to understand the player s motivation and it therefore provides reliable data for further user-oriented studies. With regard to Table 7.3, this includes the analysis of player game time behaviour as well as the effect of virtual fragmentation. Both approaches are compared with the related work afterwards in this section. Another aspect of computer gaming is the mobile environment; the statistical analysis includes a survey about the mobile gaming lobby. However, due to lack of cooperation with Eve Online, it was unfortunately not possible to test the Instant Messenger integration (which is the second contribution in the field of mobile gaming) at a real MMOG. Since the open source MMOGs do not provide the necessary number of players (most of them are not even playable currently) and other professional companies did not answer the requests for participation, it was not possible to set up an appropriate testbed with a real MMOG to evaluate the game interfaces of IM integration. Nevertheless, it is also possible to at least substantiate the middleware s functionality; therefore a GUI was designed (which uses the IM s game interfaces). The following section compares the MC Chat and the IM Integration with the related work. Finally, the third topic covers the research field of gaming middleware applications. The 4MOG middleware (which supports MMOGs with a core set of functions) is compared to the related work.
206 Table 7.3. Assessment of the related attempts and the approaches of this thesis 193 Mobility Scalability Reusability QoS User Behaviour Hardware Expenditure Mobile Aware Games Asynchronous mobile gaming RFID tags MCChat IM Integration Massive Multiplayer Games Interest-based AIs P2P MMOG architecture Public server architecture Gaming Middleware Service Platform OpenPING Middleware Patch Scheduling MOG middleware User Categorization Bullet time in multiplayer Player behaviour and design Hardcore game behaviour Virtual Fragmentation
207 Player Behaviour The research field of the influence of a player s behaviour on computer games includes various aspects; hence the approaches in this thesis aim to only improve certain aspects. Both of the questionnaires offer a wide range of interesting findings, especially concerning the cultural influence on game time. With the relatively high player effort in the MMORPG landscape, these findings offer a basis on which further approaches can be built. As a conclusion to the findings about leisure time, one can observe that not only do RPG players have the highest available leisure time, but they also have the highest percentage rate of game time. An intelligent game design that does not automatically reward a massive time investment would also help to scale in-game balancing better and therefore reduce the effects of strong addiction. On par with the game time distribution analysis, the effects from [Frit ] clearly underpin the strong influence of virtual worlds on individual behaviour. Based on the taxonomy of Bartle [Frit ] and the Five-Factor Model a clear categorization helps to personalize further game content, for example, by using a learning game application that can create specialized content for each of the online players. Compared to the player preferences and game design analysis from the related work section (3.5.2 and 3.5.3), the approaches in this section offer a more basic evaluation. Both of the results aim to include scalability, therefore both MMOGs and classic small multiplayer environments have been analyzed separately. The strong focus relies on the reusability and the integration of player behaviour. The game time distribution analysis offers basic figures on which further surveys and player categorization can be built. The effect of strong addiction has been addressed in literature more frequently over the last five years although no statistically reliable figures were provided. On the other hand, the effect of virtual fragmentation clearly opens up a new opportunity for the game design. By integrating personalized content into the next generation games, each of the players will engage in the online world more intensively because the content reflects the players interests. Combined with the architecture of intelligent AI design (like in the approach of interest-based AI design from section 3.3.1) it would also be possible to create more realistic NPCs.
208 The results of the surveys are representative, since the advertising strategy included more than 100 different game forums. The users of these forums are explicitly gameoriented, reflecting the current game scene. In order to obtain the most representative set of participants possible, the advertisement was evenly distributed among the four game types: RTS, RPG, FPS and SG. The mechanism used to collect the data (online survey) also supports a correct survey design since the users are familiar with the Internet environment and the mechanisms. Although the analysis of player behaviour offers a wide variety of possible improvements, one should still keep in mind that these underlying factors cannot solve more specific problems. By understanding the player s motivation and the mechanisms, one can design better software applications, however, the technical limitations still remain. For example: movement and language perception would be excellent for an online environment, however, they can currently not be realized Mobile Lobby The mobile gaming section contains the greatest number of technical limitations, however, the potential of wireless and flexible gaming applications is growing continuously. The approaches in this thesis aim to improve the actual usage of current equipment in order to optimize the possibilities for mobile gaming. By taking a closer look at the current mobile phone gaming section, one undoubtedly realizes that the users expectations significantly exceed the limits of current mobile gaming technology. Therefore, most of the serious gamers [Frit ] prefer to play on consoles or PC platforms due to the higher performance. Under consideration of these unequal conditions and the need for a fast game setup, the current mobile game design fails to support the players interests. The approach introduced to understand the mobile gaming sector is based on statistical data from the user survey. The surveys results are representative; the advertising strategy explicitly included game forums with mobile content (such as Sony PSP, Nintendo DS, etc.). Therefore, the survey participants reflect the users with an interest in mobile gaming. The mechanism used to collect the data (online survey) also supports a correct survey design, since the users are familiar with the Internet environment and the
209 mechanisms because many of the mobile gaming users also play games on their personal computer. By gaining insights into game type preferences as well as the importance of playing with friends, the game design can be changed accordingly in the future. Furthermore, the J2ME-based mobile phone lobby offers a flexible solution for a fast game setup, hence offering the opportunity to find possible opponents for the player for all of the installed games. The focus of this approach relies on the mobility and reusability of the application. Especially in the mobile sector, it is important to create common standards to support the large number of different mobile handheld devices. Another important aspect is the integration of game-related activities in a mobile environment. With the current display and input limitations, it is also possible to integrate game-related activities such as chatting in the mobile sector. Due to the limitations in performance, current game clients from PC and console games will not run properly on the next generation handhelds. Therefore, the integration of instant messenger applications into current MMOGs aims to merge in-game and out-of-game contacts and to create a common standard for the players. The IM application is kept as generic as possible; hence the focus relies on both mobility and reusability. It is necessary to support as many MMOGs and IMs as possible to create a flexible system for all players. By integrating these aspects into a mobile environment, a player could focus on game-related activities like in-game scheduling or chatting instead of playing games that he/she does not enjoy. Compared to the related work of asynchronous mobile gaming (3.2.1) and RFID location aware gaming (3.2.2), the approaches introduced differ slightly from the current mobile gaming strategy. Instead of integrating new technologies in order to create low-performing applications, the current resources should be used more effectively in order to improve mobile gaming. The definition of standards and reusability for future applications are particularly important aspects MOG Middleware The tremendous growth of the research field for massive multiplayer gaming reflects the great importance of the game type for the upcoming evolution. Current related
210 work within this section, especially the design of improved patch scheduling (3.4.3), further increases the number of possible mechanisms for a more effective interaction with a high number of simultaneous players. The 4MOG middleware approach in this thesis aims to integrate current techniques between the network and the game layer, hence offering various interfaces for both sides. The purpose of the middleware is to support the developer with functions in order to simplify the technical implementation of the MMOG. Therefore, the developer can spend more time on creating individual game content. One of the main advantages is the focus on reusability. Especially for the growing landscape of MMOGs, it is important to reuse effective problem solutions in order to further develop the games without substantially increasing the overall development time. In clear contrast to other middleware applications like the OpenPING middleware (3.4.2) or the service platform (3.4.1), the problem addressed in the 4MOG middleware does not focus on effective network distribution. Although the distribution of player load and effective content management are important issues for the current game design, the approaches introduced offer different effective solutions as well. Therefore, the 4MOG middleware improves player tracking and uses a penalty level system to prevent the users from spamming the server. The testbed of the 4MOG middleware is used to determine whether the spamming behaviour of the clients can be reduced with the penalty level system. Both the penalty level and the AOI (area of interest) are examples of how network traffic can be reduced, hence increasing the scalability (which is important for all MMOGs). One disadvantage of the current middleware application is the lack of mobile availability; the current technical equipment in the mobile gaming sector does not scale with high numbers of simultaneous players. Compared with the GASP middleware, the closest related approach, both applications have similarities in their underlying design. The 4MOG application also uses a message-based implementation due to the higher performance and possibility to pre-calculate locally. However, the 4MOG middleware focuses on functionalities for MMOG design and aims to support the developer, whereas the GASP middleware offers more generalized support for all multiplayer games. The GASP 197
211 middleware does not include a penalty system yet because the focus of the GASP application is not only on the MMOG sector. As explained earlier, a reduction of the server network traffic becomes more important in a massive multiplayer scenario due to the significantly higher number of clients. 198
212 Conclusion and Future Work Two wrongs don t make a right, but they make a good excuse, Thomas Szasz. This chapter contains a general conclusion about the problematic field of computer gaming. With regard to the main aspects of player behaviour, mobile gaming and middleware solutions for massive multiplayer gaming, the results are briefly summarized. Furthermore, limitations of the approaches are discussed in order to illustrate the current limitations in computer games science. Finally, possibilities for further research options are given. 8.1 Conclusion The field of computer game design is still connected to a wide variety of problems. As indicated in the introduction, a best practice solution does not exist. One should therefore consider each of the approaches separately in order to understand the contribution. Furthermore, it is also necessary to address the approaches limitations. Especially in the upcoming work, it is vital to keep these options in mind in order to create a realistic plan for future development. Therefore, it is essential to give an overview of the contribution of the dissertation in order to summarize the different parts of the thesis. Table 8.1 gives a brief overview of the most important contributions (especially source code and programming contributions) that extend the modelling and analysis of this thesis. In the context of mobile aware games, both approaches have contributed important programs to integrate mobility into the current game design. The MCChat lobby offers a flexible framework for further game expansion. With the necessary support of game developers, such an application could be used as the standard gateway for a mobile game setup. Another research approach (the IM integration) generates a middleware application to support the external chat mechanisms in the current
213 generation of massive multiplayer games. It therefore helps to move one step closer to a global player community that is not limited due to different games. 200 Table 8.1. Overview of the contribution of this thesis Emphasis Mobile Aware Games Gaming Middleware User Categorization Scientific Contribution The integration of a lobby tool that enables different clients (mostly PDAs) to build an AdHoc network and have a common lobby to find other players faster and more reliably called MCChat; another important contribution was the integration of the external communication technologies and the theoretical support of any game client: IM Integration The creation of a flexible middleware solution that is strongly MMOG-oriented and supports the designer of the games with a core set of functions: 4MOG Middleware Detailed statistical analysis of player behaviour and the design of a reusable survey platform in order to support the important aspect of empirical analysis: Hardcore Game Behaviour, Virtual Fragmentation The aspect of massive multiplayer gaming includes the design of the 4MOG middleware, which is a lightweight communication-oriented gaming middleware. The framework and necessary decisions regarding the design are discussed in this thesis. A prototype application has been created for the testbed. With a further implementation (mostly by implementing abstract classes), it would be possible to create an application that supports different MMOGs better (with individual functions that can be used optionally). As discussed above, it would also be possible to use the current tracking system in order to reduce cheating possibilities. Finally, the emphasis of user categorization also includes computer science s contribution. The design of a framework for further surveys, which also supports different languages and handles the efficient and swift integration of appropriate web front-ends, further helps to increase the number of upcoming surveys in order to
214 verify future approaches. Additionally, the gathered data about player behaviour and game-specific effects serve as a fundamental reference for further papers as well Player Behaviour In the player behaviour section, two main approaches are described in detail. The first evaluates the average game time with regard to social demographic factors, game type and occupation. The European questionnaire has clearly underscored that the average game time of MMOGs (especially MMORPGs) is significantly higher compared to other game types. The player group also shows differences with regard to age variance and social behaviour. Moreover, the amount of hardcore players is around 10% in all of the game types evaluated - these players take the game very seriously and therefore prioritize it over work and/or education. The results can be used to integrate mechanisms for a more intelligent game achievement that is less time-consuming. The second approach describes the difference between in-game and out-of-game behaviour, which is called virtual fragmentation. A survey with game-related questions uses the Five-Factor Model in order to understand which parts of the behaviour are influenced. The ensuing statistical analysis shows that several factors are responsible for the differences observed. On the one hand, the cultural factor plays an important role. The social acceptance of gaming in different European countries as well as the technological equipment appear to be the main influencing factors. On the other hand, the game type and the way that players approach the game are responsible for differences in Five-Factor Model attributes. The results can be used further to customize games in the future. As long as the necessary information for each player is provided (like classification of the game behaviour) it is possible to integrate more specific content for each user (like personalized quests or on-the-fly created landscapes that fit the users preferences) Mobile Gaming In the mobile gaming section, the thesis describes the main technological problems of the current mobile game design. In order to analyze the players perspective, a
215 survey evaluates the mobile users preferences. Therefore, two approaches in this thesis improve the current mobile game environment. The MCChat offers a flexible lobby application that creates a common chat platform with interfaces to the mobile games. Hence, the matching time for mobile game sessions is significantly reduced when using a common gateway. The importance of mobile communication has also experienced tremendous growth over the last few years. Thus, the IM integration aims to implement any current instant messenger into MMOGs by offering interfaces for the basic chat functionalities. Existing buddy lists of in-game and out-of-game contacts can therefore be merged. In terms of a mobile environment, this integration reveals that even when the game client is not running, a user can still stay in touch with in-game friends MOG Middleware The aspect of massive online gaming has a significant influence on the current game design. As [MMOR] shows, the number of MMOGs released over the last few years is increasing rapidly. With regard to the number of players of top-selling MMOGs (like World of Warcraft or Linerage 2), one can observe that the games are becoming very popular (both games have over 7 million subscribers worldwide who pay to play the games). The 4MOG middleware therefore provides the core set of functions for designers of MMOGs with interfaces for network features in order to reduce technical programming efforts. Also by tracking each player, further features can be included like cheat protection for movement exploits, a specific analysis of the player behaviour or a detailed statistic of the in-game load balance. The testbed results indicate a stable scalability towards the TCP and UDP layer, also the technique of AOI management is used as an example to reduce the overall network bandwidth. Furthermore, another aspect of the bandwidth reduction was analyzed; the testbed included a penalty level system to permit brute force attacks on the game server.
216 8.2 Future Work 203 The current work presented in this thesis covers different aspects of the game research (such as player characterization, mobile gaming and massive multiplayer gaming). Since the field of game research is comparably young, some parts of the work (like the player behaviour analysis) are performed with the objective of creating underlying data for further research approaches. As demonstrated, the different approaches aim to increase both the understanding of player interaction as well as to further increase the quality of main aspects of next generation game design (like mobile and massive multiplayer gaming). Before providing an outlook for future improvements, one must also take a close look at the limitations of current game development with regard to the three main aspects of this thesis. Player behaviour. As indicated, the understanding of current player behaviour is a prerequisite for a better game design. Identifying negative results from in-game values like the creation of sweatshops helps to understand the current situation, although it does not create a solution for it. An intelligent game design could prevent these abusive strategies, but strictly limiting in-game trading or reducing the players opportunities will also have negative consequences. This dilemma depicts one of the limitations; even with a deep understanding of the game mechanisms, a solution can only be identified by the industry. As long as the current game design fulfills the needs of the player community, the alternatives will not be taken into account. Furthermore, the statistical analysis also has its limitations; by understanding the average player it is not possible to exclude negative effects. The most well-known example is the predicted negative adoption of in-game violence for real world behaviour. Several research approaches aim to prove the positive aspects of computer gaming, however, it is not the median (average) player who should be evaluated. Since statistical analyses always feature a small mistake probability, even with a 5% error factor it leaves considerable room for a single exception. For the example of in-game violence and real-life behaviour, this means that even if a clear statistical correlation between computer gaming and a positive real-life behaviour is shown, there can be still exceptions (like a single person running amok after playing
217 a FPS). Therefore, it is also not possible to exclude certain behaviour; a prediction always aims to understand the majority. With regard to the limitations mentioned, the upcoming player behaviour analysis can extend current results. One of the main problems addressed for the future is the influence of long-time game sessions on the player s performance. Using in-game calculation as well as eye movement tracking can help to understand the general change in perception after a long game session. Furthermore, the psychological effects can be used for an improved game design; personalized content that depends on the player s characteristics would take the current game design to a new level. Mobile gaming. This section probably includes the greatest number of limitations with regard to technology. The vision behind mobile gaming is a completely mobile environment that allows the player to use entertainment software everywhere. Unfortunately, this cannot be realized with the current equipment. Two main factors prevent such a mobile environment: Most of the current handhelds cannot support next generation games. This is especially due to the strict limitations in display and input. The negative limitation effects are evaluated in-depth in [Frit ], showing that PC performance with the same games is superior as opposed to the mobile devices. Also due to the maximum resolution of 480x320 pixels, it is not possible to use current 3D models from PC games because their complexity (number of polygons, texture depth) exceeds the performance of the mobile devices graphical adapters. This reduces the graphical quality further compared to the console and PC sector. Furthermore, the structure of the mobile network is a major problem for next generation gaming. Both the GSM/UMTS and the WLAN/Bluetooth opportunities have individual advantages and disadvantages for game design, although real-time games (like FPS or RTS) set strict requirements for maximum latency, which GSM/UMTS cannot provide. In addition, in order to be truly mobile, a network connection must be established at any and all locations. However, this aspect is not provided either due to the limited signal range of WLAN and Bluetooth. In summarizing both disadvantages, neither GSM/UMTS nor WLAN/Bluetooth can support real-time mobile games completely (the design must take the drawbacks of the network structure used into account). 204
218 Besides these two main problematic fields, the aspect of the lack of standardization also poses a barrier to the creation of a common game design for all platforms. Mobile game devices today are broken down into the gaming-oriented handhelds (like Nintendo DS or Sony PSP), mobile phones and PDAs; each of the categories features different sub-groups as well. Especially in the mobile phone sector that has a wide variety of devices, the missing standards lead to multiple, non-compatible versions of the same game. Undoubtedly, the current technical situation strictly limits the evolution of mobile game design. Nevertheless, the mobile lobby and integration of IM software for the mobile devices offer flexible solutions to improve certain aspects (like a faster game setup). In the future, the implementation of the mobile lobby can be further improved by supporting additional next generation devices, thus creating a common standard for spontaneous game setups. Based on the evolution of a next generation in handheld devices, newer evaluations can lead to deeper insights. Due to the rapidly evolving mobile gaming field, next generation devices will reduce technological limitations, hence creating the preconditions for further approaches. Massive multiplayer gaming. As one can see, most attempts for game design are created in the massive multiplayer game sector. Due to the scalability problem of the S/C structure and the opposing motivation of high controllability by the publisher, most of the network solutions tend to offer a better performance, but one disadvantage is that they limit the controlling options. Therefore, these attempts present theoretical advantages with regard to scalability, but none of them have been implemented in a commercial game to date. An analysis of the limitations of massive multiplayer gaming today leads to the identification of several aspects that are responsible for current problems. The setup of a persistent online world with the players income also creates a virtual economy. Although the second generation of MMOGs integrates mechanisms to limit in-game inflation, several problems still arise (like real world values of the virtual goods). As described above, the current commercial game design does not support intelligent solutions due to a lack of understanding of the players motivation. Another important limitation is the online game world s size. Nevertheless, the usage of shards to equally distribute the overall number of players on multiple servers aims 205
219 to limit the maximum number of simultaneous players to less than 15,000 users. A new network protocol and higher server performance would increase this maximum number slightly, however, the general problem of scalability combined with less to no loss in control is still not resolved. Moreover, the limitation of available content is another significant topic. The AI of the NPCs has improved significantly over the last five years. However, the evolution has just begun, leading to growing interaction complexity and the individual motivation of each NPC. Complexity of the game worlds is expected to increase further which is why expanding the static persistent environments with on-the-fly content or expanding the game world is another concept that has not been realized yet. By taking the various limitations into account, one can understand that research in the field of massive multiplayer gaming still needs to address a wide variety of problematic fields. Extending beyond the middleware approach introduced in this thesis, the upcoming work will certainly include a further improvement of the 4MOG application. One possible evolution would be to integrate player characteristics for each client. In-game content could be personalized with data gathered, which would subsequently create special events for each of the players. For example, based on the classification of Bartle, an explorer would receive an additional, generically created area to explore. The game would therefore reward each gaming strategy by understanding each client s preferences. 206
220 Appendix In the future everyone will be famous for fifteen minutes, Andy Warhol. This section contains the most important abbreviations as well as a reference for further statistical results. 9.1 Abbreviations and Glossary AI AFK ASP Beta test Bot Casual Clan Cellular Input Death match DHT Endgame Artificial Intelligence (mostly NPCs) Away From Keyboard Active Server Pages Beta stage of the software lifecycle in game production, mainly with the active help of participating test players Automated program to act in-game, often used for farming In terms of gaming: approaching the game with (below) average interest A union of players with the same goal, often a cooperative institution A mobile phone s input options, available key can differ in terms of number and placement depending on the phone. Generally, the input includes the typical ITU-T keypad for dialling A special game type where each battles against all of the others; the player with the highest score wins Distributed Hash Table The game content for experienced players with in-game characters on the highest level
221 208 ER model Farm(ing) FPS Group Guild Hardcore MMOFPS MMOG MMORPG MMOSpace MOS NPC OSCAR P2P PC PvE PvP Raiding RPG RTS S/C Entity Relationship Model (for database design) Playing the game in order to only gather resourses like gold or other treasures First Person Shooter A temporary in-game collaboration of fellow players who have the same goal A long-term, larger scaling collaboration of players who have a similar game attitude A behaviour towards the game; describes a far above average interest in the game content and a strong motivation to achieve Massive Multiplayer Online First Person Shooter Massive Multiplayer Online Game Massive Multiplayer Online Role Playing Game Massive Multiplayer Online Space Setting Mean Opinion Score. Non-Player Character Open Service for Communication in Real-Time Peer-To-Peer Player Character or Personal Computer Player versus Environment Player versus Player A large group of cooperating players who have teamed up to beat a single strong opponent Role Playing Game Real-Time Strategy Server/Client Structure
222 209 SG UMMORPG Sports Game Ultra Massive Multiplayer Online Role Playing Game 9.2 Additional Figures Figure 9.1. Illustration (ER model) of the GASP middleware server domain model. It serves as a general specification for programming. Figure 9.2. UML Diagram of the 4MMOG middleware network classes. The network interface is implemented in detail by a server and a client (with individual functionalities).
223 210 Figure 9.3. UML view of the 4MMOG middleware s client side Figure 9.4. UML view of the 4MMOG middleware s server side.
224 211 Figure 9.5. Example of the message system in the middleware application. Each message has its own type (implemented in XML), which enables all important parameters to be specified and the existing message system to be expanded if necessary.
225 212 Figure 9.7. UML Diagram of the complete message system. It also includes a limited set of functions for the NetworkMessage() class. As one can see, the MessageListener uses the observer pattern to minimize the communication efforts required.
226 213 Figure 9.8. Complete overview of the middleware s client side. Figure 9.9. Complete overview of the middleware s server side.
227 Figure First solution approach for the IM integration. On the EVE client side, extension was necessary to (a) access IM clients and server data, (b) give users the possibility to control these clients, (c) create client to access the AIM network. On the EVE server side, an extension was also necessary to provide the user data required by the clients. 214
228 Figure Final solution for the IM integration. By making use of the OPIS server, the name mapping problem can be solved easily. On the EVE server side, no extension is necessary. All IM functionalities are implemented on the EVE client side. The connection between the EVE server and client is only the standard connection used for the actual game. 215
229 216 Figure The IM framework s component structure. The prototype developed is the IMInterface, the communication core to provide Instant Messaging. EVE Client symbolizes any GUI to use the IMInterface, an it can be substituted by another GUI. AccCoreLib is the section of the AIM SDK that enables communication with the AIM network. Additional sub-systems would be required to support multiple protocols.
230 Figure Class overview of the IMInterface. The central point and main access point from the GUI is the ClientManager that can manage multiple clients (implementations of the ClientInterface). The BuddyList internally represents the consolidated contact lists of all connected clients and thus manages multiple contacts (Buddys). The AimClient implements all methods of ClientInterface and uses the AccCoreLib of the AIM SDK to access the AIM network. Currently, the MsnClient does not exist and is only shown for demonstration purposes. The ClientInterface and its implementations have safeguarded access and can only be accessed from within the IMInterface. Certain global lists have been defined for several purposes. Only the key methods are shown for the classes, although more actually exist. 217
231 Figure Sequence diagram for the connection process in the IM framework. 218
232 Figure Methods of the ClientManager in the IM framework. 219
233 220 Figure Methods of the ClientInterface in the IM framework. Figure Methods of the AimClient in the IM framework.
234 221 Figure Methods of the BuddyList in the IM framework Figure Methods of the Buddy in the IM framework
Mobile Phone Gaming (A Follow-up Survey of the Mobile Phone Gaming Sector and its Users)
Mobile Phone Gaming (A Follow-up Survey of the Mobile Phone Gaming Sector and its Users) Tobias Fritsch, Hartmut Ritter, Jochen Schiller Freie Universität Berlin, Technical Computer Science Workgroup,
Tutorial: Traffic of Online Games
Tutorial: Traffic of Online Games Jose Saldana & Mirko Suznjevic IETF 87, Berlin, August 1 st, 2013 Transport Area Open Meeting 1.8.2013. 1 Goals of this presentation Information about current practices
Mobile Game Project Proposal
Mobile Game Project Proposal Chris Moolenschot Gareth Vermeulen UCT CS Honours Project 14 July 2006 Project Description With the world-wide proliferation of mobile technology the field of so-called ubiquitous people, simple bound on the game server computing power
A simple bound on the game server computing power By: Lam Ngok Objective In this preliminary study, we employed some simple results from the queueing theory literature to derive a bound on the computing
QoS Issues for Multiplayer Gaming
QoS Issues for Multiplayer Gaming By Alex Spurling 7/12/04 Introduction Multiplayer games are becoming large part of today s digital entertainment. As more game players gain access to high-speed internet
OCR LEVEL 3 CAMBRIDGE TECHNICAL
Cambridge TECHNICALS OCR LEVEL 3 CAMBRIDGE TECHNICAL CERTIFICATE/DIPLOMA IN IT DEVELOPING COMPUTER GAMES K/601/7324 LEVEL 3 UNIT 10 GUIDED LEARNING HOURS: 60 UNIT CREDIT VALUE: 10 DEVELOPING COMPUTER GAMES
Storage Technologies for Video Surveillance
The surveillance industry continues to transition from analog to digital. This transition is taking place on two fronts how the images are captured and how they are stored. The way surveillance images
Global entertainment and media outlook 2009 2013. Video Games. Segment Summary
Global entertainment and media outlook 2009 2013 Video Games Segment Summary Global Outlook Globally, the video game market will grow from $51.4 billion in 2008 to $73.5 billion in 2013, a 7.4 percent
Europe s Video Game Industry and the Telecom Single Market
Executive Summary The internet is a key driver of growth in the video game industry and facilitates distribution of content, engagement with customers, multiplayer gameplay and provision of crucial software
Implementation of a Video On-Demand System For Cable Television
Implementation of a Video On-Demand System For Cable Television Specific VOD Implementation for one way networks This white paper is co-authored by: Teleste Oyj Edgeware AB 1(18) TABLE OF CONTENTS Confidentiality
The Integrated Media Enterprise
The Integrated The Integrated Media production and distribution businesses are working in an environment of radical change. To meet the challenge of this change, a new technology and business
White Paper. Enterprise IPTV and Video Streaming with the Blue Coat ProxySG >
White Paper Enterprise IPTV and Video Streaming with the Blue Coat ProxySG > Table of Contents INTRODUCTION................................................... 2 SOLUTION ARCHITECTURE.........................................
Giving life to today s media distribution services
Giving life to today s media distribution services FIA - Future Internet Assembly Athens, 17 March 2014 Presenter: Nikolaos Efthymiopoulos Network architecture & Management Group Copyright University of
Application Visibility and Monitoring >
White Paper Application Visibility and Monitoring > An integrated approach to application delivery Application performance drives business performance Every business today depends on secure, reliable
An introduction to the video games world. S. Natkin, htpp://
An introduction to the video games world S. Natkin, [email protected] htpp:// The six cycles of the video game history: the starting point Each cycle start with a new
Pikko Server. Scalability when using Erlang on the server side for massive multiplayer game servers. David Almroth CTO, PikkoTekk
Pikko Server Scalability when using Erlang on the server side for massive multiplayer game servers. David Almroth CTO, PikkoTekk Agenda 1. David & PikkoTekk 2. Normal game servers 3. The scalability problem
Cloud Based Application Architectures using Smart Computing
Cloud Based Application Architectures using Smart Computing How to Use this Guide Joyent Smart Technology represents a sophisticated evolution in cloud computing infrastructure. Most cloud computing products
for High Performance Computing
Technische Universität München Institut für Informatik Lehrstuhl für Rechnertechnik und Rechnerorganisation Automatic Performance Engineering Workflows for High Performance Computing Ventsislav Petkov
Legal Offers for Consumers in the Video Games Industry
Legal Offers for Consumers in the Video Games Industry Born digital, video games have become, in just four decades, a popular form of mass entertainment, a powerful and exciting platform for innovative
PQoS Parameterized Quality of Service. White Paper
P Parameterized Quality of Service White Paper Abstract The essential promise of MoCA no new wires, no service calls and no interference with other networks or consumer electronic devices remains intact
Whitepaper. Controlling the Network Edge to Accommodate Increasing Demand
Whitepaper Controlling the Network Edge to Accommodate Increasing Demand February 2007 Introduction A common trend in today s distributed work environment is to centralize applications and the data previously
Efficient evolution to all-ip
Press information June 2006 Efficient evolution to all-ip The competitive landscape for operators and service providers is constantly changing. New technologies and network capabilities enable new players
Solace s Solutions for Communications Services Providers
Solace s Solutions for Communications Services Providers Providers of communications services are facing new competitive pressures to increase the rate of innovation around both enterprise and consumer
The game operator s toolkit: The essentials and beyond
The game operator s toolkit: The essentials and beyond I. Summary Live games don t just need great game operations strategies, they need great tools. In this paper you will learn about the key tools-
Contents LIST OF FIGURES...VIII LIST OF TABLES... X ABSTRACT...XI 1. INTRODUCTION... 1
Contents LIST OF FIGURES...VIII LIST OF TABLES... X ABSTRACT...XI 1. INTRODUCTION... 1 1.1 COLLABORATIVE AUDIO... 2 1.2 THE SPECIFIC FOCUS OF THIS THESIS... 8 1.3 THESIS OVERVIEW AND CONTRIBUTIONS... 9,
Key Requirements for a Job Scheduling and Workload Automation Solution
Key Requirements for a Job Scheduling and Workload Automation Solution Traditional batch job scheduling isn t enough. Short Guide Overcoming Today s Job Scheduling Challenges While traditional batch job
Ensuring Real-Time Traffic Quality
Ensuring Real-Time Traffic Quality Summary Voice and video calls are traffic that must arrive without delay at the receiving end for its content to be intelligible. This real-time traffic is different
Automated quality assurance for contact centers
Assuring Superior Customer Experience Automated quality assurance for contact centers Automated quality assurance for contact centers QA5 is a software solution for emotion detection, utilizing Nemesysco
TABLE OF CONTENTS. Source of all statistics:
TABLE OF CONTENTS Executive Summary 2 Internet Usage 3 Mobile Internet 6 Advertising Spend 7 Internet Advertising 8 Display Advertising 9 Online Videos 10 Social Media 12 About WSI 14 Source of all statistics:
Inventory and Analytics for Browser-based Applications in the Enterprise
Inventory and Analytics for Browser-based Applications in the Enterprise Introduction Times are changing. Desktop and client/server business applications (collectively referred to as native applications
Scala Storage Scale-Out Clustered Storage White Paper
White Paper Scala Storage Scale-Out Clustered Storage White Paper Chapter 1 Introduction... 3 Capacity - Explosive Growth of Unstructured Data... 3 Performance - Cluster Computing... 3 Chapter 2 Current
IBM Social Media Analytics
IBM Analyze social media data to improve business outcomes Highlights Grow your business by understanding consumer sentiment and optimizing marketing campaigns. Make better decisions and strategies across
Human Computer Interaction (User Interfaces) for Games
Human Computer Interaction (User Interfaces) for Games IMGD 4000 Background HCI Principles HCI and Games Topics 1 What do these things have in common? A Computer Mouse A Touch Screen A program on your
Mobile Communications Chapter 9: Mobile Transport Layer
Mobile Communications Chapter 9: Mobile Transport Layer Motivation TCP-mechanisms Classical approaches Indirect TCP Snooping TCP Mobile TCP PEPs in general Additional optimizations Fast retransmit/recovery
The Next Generation Network:
JULY, 2012 The Next Generation Network: Why the Distributed Enterprise Should Consider Multi-circuit WAN VPN Solutions versus Traditional MPLS Tolt Solutions Network Services 125 Technology Drive Suite
Where do you manage heterogeneous bandwidth requirements?
Introduction The emergence of Unified Communications (UC) represents the next step in the evolution of converged communications. Whereas the initial benefits of converging communications on the IP networks
Understanding Neo4j Scalability
Understanding Neo4j Scalability David Montag January 2013 Understanding Neo4j Scalability Scalability means different things to different people. Common traits associated include: 1. Redundancy in the
Application Compatibility Best Practices for Remote Desktop Services
Application Compatibility Best Practices for Remote Desktop Services Introduction Remote Desktop Services in Windows Server 2008 R2 allows Windows Server to be accessed by multiple users concurrently
Bandwidth Aggregation, Teaming and Bonding
Bandwidth Aggregation, Teaming and Bonding The increased use of Internet sharing combined with graphically rich web sites and multimedia applications have created a virtually insatiable demand for Internet
ASCETiC Whitepaper. Motivation. ASCETiC Toolbox Business Goals. Approach
ASCETiC Whitepaper Motivation The increased usage of ICT, together with growing energy costs and the need to reduce greenhouse gases emissions call for energy-efficient technologies that decrease the overall
INSIGHTS FROM OPERA MEDIAWORKS
INSIGHTS FROM OPERA MEDIAWORKS 9 of the top AD AGE GLOBAL ADVERTISERS OVER 800M UNIQUE USERS OVER 18,000 SITES AND APPLICATIONS Year closes out with Apple No. 1 for revenue, Android leading in
WHITE PAPER. Solutions for the Broadband User Enigma *"%+,$ !"#$ %"&$ '()($ Consolidating Subscriptions through Unprecedented Business Intelligence
WHITE PAPER *"%+,$!"#$ %"&$ '()($ Solutions for the Broadband User Enigma Consolidating Subscriptions through Unprecedented Business Intelligence vennetics.com Removing the Mystery from Broadband Users
Customer Intimacy Analytics
Customer Intimacy Analytics Leveraging Operational Data to Assess Customer Knowledge and Relationships and to Measure their Business Impact by Francois Habryn Scientific Publishing CUSTOMER INTIMACY ANALYTICS
IBM Social Media Analytics
IBM Social Media Analytics Analyze social media data to better understand your customers and markets Highlights Understand consumer sentiment and optimize marketing campaigns. Improve the customer experience
Lab 6: Wireless Networks
Lab 6: Wireless Networks EE299 Winter 2008 Due: In lab, the week of March 10-14. Objectives This lab will show a correlation among different network performance statistics with multimedia experiences,
SCALABILITY AND AVAILABILITY
SCALABILITY AND AVAILABILITY Real Systems must be Scalable fast enough to handle the expected load and grow easily when the load grows Available available enough of the time Scalable Scale-up increase
Traffic Monitoring in a Switched Environment
Traffic Monitoring in a Switched Environment InMon Corp. 1404 Irving St., San Francisco, CA 94122 1. SUMMARY This document provides a brief overview of some of the issues involved in monitoring
Fast Paced Strategy Mobile Game
HKUST Independent Project CSIT 6910A Spring 2014 Report Fast Paced Strategy Mobile Game Submitted By, Email: [email protected] MSc. Information Technology (2013), HKUST Supervised by, Dr. David Rossiter
Bandwidth Management for Peer-to-Peer Applications
Overview Bandwidth Management for Peer-to-Peer Applications With the increasing proliferation of broadband, more and more users are using Peer-to-Peer (P2P) protocols to share very large files, including
Intelligent Content Delivery Network (CDN) The New Generation of High-Quality Network
White paper Intelligent Content Delivery Network (CDN) The New Generation of High-Quality Network July 2001 Executive Summary Rich media content like audio and video streaming over the Internet is becoming,
Enabling the Wireless School Challenges & Benefits of Wireless LANs in Primary Education
WHITE PAPER Enabling the Wireless School Challenges & Benefits of Wireless LANs in Primary Education Date: February 2009 Copyright 2010 Meru. All rights reserved. TABLE OF CONTENTS INTRODUCTION... 3 GROWING
Server Virtualization and Network Management
Server Virtualization and Network Management White Paper Author: Dirk Paessler Published: August 2008 [email protected] the network monitoring company CONTENTS EXECUTIVE SUMMARY 3 WHY
the gamedesigninitiative at cornell university Lecture 15 Game Analytics
Lecture 15 The Rise of Big Data Big data is changing game design Can gar data form a huge number of players Can use that data to inform future content What can we do with all that data? What types of questions
Solving sync. Synchronized Live OTT. Solution Paper
Solving sync Synchronized Live OTT Solution Paper Live is what you make it With millions of free videos online, audiences are spoiled for choice. But the more content viewers have to choose from, the less
Keywords IS-SDE, software engineering, CALM, ALM, collaborative software development, development tools
Volume 5, Issue 9, September 2015 ISSN: 2277 128X International Journal of Advanced Research in Computer Science and Software Engineering Research Paper Available online at: An Integrated
1.0 Introduction and Report Overview
1.0 Introduction and Report Overview A revolution is taking place in application infrastructure and integration. New technologies and concepts such as Web services, service-oriented architecture (SOA)
Application Performance Testing Basics
Application Performance Testing Basics ABSTRACT Todays the web is playing a critical role in all the business domains such as entertainment, finance, healthcare etc. It is much important to ensure hassle-free
The Internet and Network Technologies
The Internet and Network Technologies Don Mason Associate Director Copyright 2013 National Center for Justice and the Rule of Law All Rights Reserved Inside vs. Outside Inside the Box What the computer
Network Management and Monitoring Software
Page 1 of 7 Network Management and Monitoring Software Many products on the market today provide analytical information to those who are responsible for the management of networked systems or what
Nine Use Cases for Endace Systems in a Modern Trading Environment
FINANCIAL SERVICES OVERVIEW Nine Use Cases for Endace Systems in a Modern Trading Environment Introduction High-frequency trading (HFT) accounts for as much as 75% of equity trades in the US. As capital | http://docplayer.net/937580-Freie-universitat-berlin.html | CC-MAIN-2018-05 | en | refinedweb |
Problem:
You want to retrieve a ZIP file by downloading it from an URL in Python, but you don’t want to store it in a temporary file and extract it later but instead directly extract its contents in memory.
Solution:
In Python3 can use
io.BytesIO together with
zipfile (both are present in the standard library) to read it in memory.
The following example function provides a ready-to-use generator based approach on iterating over the files in the ZIP:
import requests import io import zipfile def download_extract_zip(url): """ Download a ZIP file and extract its contents in memory yields (filename, file-like object) pairs """ response = requests.get(url) with zipfile.ZipFile(io.BytesIO(response.content)) as thezip: for zipinfo in thezip.infolist(): with thezip.open(zipinfo) as thefile: yield zipinfo.filename, thefile | https://techoverflow.net/category/allgemein/ | CC-MAIN-2018-05 | en | refinedweb |
Agenda
See also: IRC log
MS: is this still draft?
SAZ: not yet approved by AC
MS: we are behind, were supposed to public Last
Call for the EARL Schema
... also need to publish first draft of the EARL Guide
... also the Requirements document
SAZ: there are change requests for the requirements document in the f2f minutes and in tracker
MS: need to get started on test suites to catch
up
... what are the plans?
CV: working now on it
SAZ: if we publish EARL Schema WD by mid-end
April
... we could aim for a the big Last Call publication for beginning of June
... that means EARL 1.0 Schema + HTTP-in-RDF + Content-in-RDF + Pointers-in-RDF
... is this realistic?
JK: doing on-going changes
SAZ: forgot, EARL 1.0 Guide should be part of the "big publication"
CV: should be possible
JK: am on vacation during second half of May
SAZ: if you can get the changes done before then
it would be useful
... most worried about the Guide
... back to test suites, what do we need to host them?
MS: generated tests serve as test suites?
SAZ: could we provide test results for the WCAG
2.0 Test Samples?
... would provide the according tests (for the context)
... but adds a dependency
CV: mixing two objectives
... can provide examples of valid and invalid EARL reports
MS: need to describe how the test suites should look like
CV: EARL does not require accessibility tests
SAZ: instead of inventing test criteria, my thought was to reuse the WCAG 2.0 Test Samples
<cvelasco> typo in related instances earl:cantTell
SAZ: removed OWL namespace and fixed namespace
for DC elements and DC terms
... added instances for OutcomeValue in Section 2.7, Appenix A, and the RDF file
... need to discuss these changes
CV: wording for Related Instances is too weak
JK: don't think it's too weak
<JohannesK> JK: change "can not" to "cannot"?
MS: maybe we get a question why we didn't do this for Test Mode
JK: last week we discussed that Test Mode doesn't need subclassing
MS: isn't that clear to me
SAZ: how about adding an editor's note in section Test Mode to ask for feedback?
[agreement]
JK: isn't "cannot" one word?
MS: yes, one word
RESOLUTION: Shadi to change "can not" to "cannot"
CV: don't like acronyms in upper case for instance names
SAZ: instance names were not discussed
... it is generally not considered good practice to differentiate between to entities using just the casing
[agreement to "passed", "failed", and "cantTell"]
MS: how about earl:na and earl:nt (lower case)?
<MikeS> other option sfor names is 'inapplicable' and 'untested'
RESOLUTION: Shadi to change "NA" and "NT" to "inapplicable" and "untested"
MS: everyone set?
... other issues?
SAZ: in this publication we are looking for feedback on: 1. use of foaf:Document, 2. instances for TestMode (like OutcomeValue), 3. replacing earl:Software with DOAP, 4. conformance section
<scribe> ...pending adding these 4 questions to the "Status of the Document", and making the two changes discussed above, any objection to publication?
JK: range for earl:info is Literal or XML:Literal?
MS: think Literal
JK: should be RDF namespace?
... actually RDFS
<JohannesK> <>: rdfs:Literal
RESOLUTION: Shadi to change range of earl:info to rdfs:Literal
<JohannesK> So it should be <>
RESOLUTION: publish EARL 1.0 Schema as an updated Working Draft pending the three changes recorded above
SAZ: regrets for the 15th
MS: next week discuss EARL 1.0 Guide and
Requirements document
... next meeting *15 April* | http://www.w3.org/2009/04/08-er-minutes.html | CC-MAIN-2018-05 | en | refinedweb |
].
Table of Contents
- Introduction
- Dependencies
- The EnvironmentMapping Demo Application
- The Shader Effects
- References
- Download the Source
Introduction
If you have ever tried to create a ray tracer or a path tracer, then you should be familiar with the concept of reflections and refractions. Rendering methods such as ray tracing and path tracing can simulate these effects naturally however GPU rasterization cannot. It is the job of the shader programmer to come up with a method that can somehow simulate the same effect that can be achieved using a global illumination rendering method such as ray tracing and path tracing. The image below shows an example render using ray-tracing.
The reflection and refraction technique displayed in the image above is an example of the effect that can be achieved from global illumination rendering algorithms. Our goal is to reproduce this effect as closely as possible in real-time.
Using a global illumination rendering algorithm (ray tracing or path tracing), you can achieve effects such as self-reflection and self-refraction. Self-reflection is when parts of the same object are reflected onto itself (for example, the handle of a teapot is reflected in the body of the teapot), and self-refraction is when parts of the object that appear behind the object can be accurately refracted. In GPU shaders, these effects are harder to reproduce.
In this article, I will demonstrate a simple method to simulate environment reflection and refraction techniques using GPU shaders. EnvironmentMapping Demo Application
I will first show how we can setup the application to use the shaders that will be shown later. I am using an effect framework which I created to simplify loading shaders, accessing and update shader parameters, and iterating through the passes of a technique. For a detailed explanation of this framework and the underlying Cg code, you can refer to my article titled [Introduction to Cg Runtime with OpenGL]
Globals and Headers
Let’s start by including the headers and defining the global variables that are used for this demo.
#include "EnvironmentMappingPCH.h" #include "Application.h" #include "PivotCamera.h" #include "ElapsedTime.h" #include "EffectManager.h" #include "Material.h" #include "Effect.h" #include "EffectParameter.h" #include "Technique.h" #include "Pass.h" #include "Events.h"
I’m using the effect framework library to create the initial OpenGL application window as well as to load shader effects and access shader parameters. These first headers (with the exception of the precompiled header) are all from the effect framework.
Then we will define a few global parameters that are used throughout the demo.
Application g_App( "Environment Mapping Demo", 512, 512 );_BrushedMetalTexture = 0; GLuint g_GlassTexture = 0; Material g_ReflectiveMaterial; Material g_RefractiveMaterial; Material g_ReflectRefractMaterial; bool g_bAnimate = true; float g_fRotatePrimitive = 0.0f; glm::ivec2 g_CurrentMousePos(0); bool g_bLeftMouseDown = false; bool g_bRightMouseDown = false;
The g_App parameter is used to startup and run the application. To handle the application logic and rendering, callback functions will be registered with the application that will be invoked in the applications update loop.
The g_Camera parameter implements a simple arc-ball camera class that also supports zooming and panning of the camera. Following the camera parameter are several parameters that define an initial view that will be applied to the camera when the application starts.
Initially I was using glutSolidTorus to render a torus that can be used to demonstrate the effects used in this demo, but glutSolidTorus doesn’t generate texture coordinates. I needed to generate texture coordinates for the geometry so the alternative was to generate a procedural torus with correct texture coordinates and normals. The g_TorusDisplayList is used to store the ID of a display list that can be used to render the same torus multiple times without having to generate the vertex position, texture coordinate, and surface normal for every render frame.
We also need to define a few texture object ID’s for the textures that will be used for this demo. The g_EnvCubeMap parameter stores the ID of the 6-sided cube map texture. The g_BrushedMetalTexture parameter defines an ID for a brushed-metal 2D texture that will be applied to the reflective material and the g_GlassTexture parameter defines a 2D texture ID for a glass texture that will be applied to the refractive material.
The g_bAnimate and g_fRotatePrimitive parameters store some animation data that is used to rotate the scene objects. The animation can be toggled by pressing the [space] bar.
And the final three parameters define information about the mouse position and the state of the mouse buttons. These are used to pan and rotate the view of the camera.
Forward Declarations
The functions that will be used as callbacks for the application class must be forward declared before they can be used. ); void InitGL(); void LoadResources(); void DrawCubeMap( GLuint texID );
The first group of methods will be registered as callbacks for the application to invoke when certain events occur.
In InitGL static OpenGL states will be configured.
The LoadResources method is used to load any textures and models that are used by the demo.
The DrawCubeMap method will draw the skybox using the cube map texture that is passed as an argument.
The Main Method
The entry point for our application is the main method. We will use it to register the callback functions that will be used for the application and startup the applications update loop.’s initial position an orientation are initialized and the callback functions are registered with the application class.
The applications processing loop is initialized by calling the Application::Run method.
The OnInitialize Method
The first thing that happens after the application has initialized is the Application::Initialized event is invoked causing the OnInitialize method to be invoked.
void OnInitialize( EventArgs& e ) { //7E1_reflection.cgfx", "C7E1_reflection" ); effectMgr.CreateEffectFromFile( "Resources/Shaders/C7E3_refraction.cgfx", "C7E3_refraction" ); effectMgr.CreateEffectFromFile( "Resources/Shaders/C7E3_refract_reflect.cgfx", "C7E3_refract_reflect" ); // Setup refective material g_ReflectiveMaterial.Reflection = 0.5f; // Setup refractive material g_RefractiveMaterial.Refraction = 0.95f; g_RefractiveMaterial.Transmittance = 0.8f; // Setup reflective/refractive material g_ReflectRefractMaterial.Reflection = 1.0f; g_ReflectRefractMaterial.Refraction = 0.95f; g_ReflectRefractMaterial.Transmittance = 0.5f; InitGL(); }
The first thing we do in this function is create and initialize the EffectManager singleton instance and get a reference to that instance.
I decided to use a torus to demonstrate this effect so the CreateTorusDisplayList method will create an OpenGL display list that can be used to quickly render the torus geometry in the scene.
The LoadResources is responsible for loading the texture and model resources used by the demo. It will load the cube map texture and the 2D texture resources.
On line 192 we register a callback method with the effect manager which will be invoked when an effect is loaded. We will use this event to set the static parameters of the effect after they are loaded (or reloaded).
On lines 196-198 the effect files are loaded by the effect manager. The first effect loaded on line 196 is the reflection effect, the refraction shader effect is loaded on line 197, and a shader that combines both the reflection and refraction effect is loaded on line 198.
For this demo, I’ve added a few new parameters to the Material type to define the reflection, refraction, and diffusion parameters that are used to simulate the reflection and refraction phenomenon. I will discuss how these parameters are used in the section where the shader programs are discussed.
On line 212, the InitGL method will initialize a few OpenGL states and parameters.
Let’s first take a look at how the torus display list is generated.
The CreateTorusDisplayList Method
The CreateTorusDisplayList method will generate a display list that can be used to render a torus without having to compute the vertex positions, texture coordinates and normals each frame.
If you would like to know more about the math behind the torus, you can refer to the [Torus] Wikipedia page ().
GLuint CreateTorusDisplayList( GLdouble innerRadius, GLdouble outerRadius, GLint sides, GLint rings ) { static const float _2_PI = 6.283185307179586476925286766559f; float stepU = _2_PI / sides; float stepV = _2_PI / rings; float u, v; GLuint displayList = glGenLists(1); glNewList(displayList, GL_COMPILE ); { for ( u = 0; u < _2_PI; u += stepU ) { glBegin( GL_QUAD_STRIP ); for ( v = 0; v < _2_PI; v += stepV ) { TorusVertx( u, v, innerRadius, outerRadius ); TorusVertx( u+stepU, v, innerRadius, outerRadius ); } TorusVertx( u, _2_PI, innerRadius, outerRadius ); TorusVertx( u + stepU, _2_PI, innerRadius, outerRadius ); glEnd(); } } glEndList(); return displayList; }
Fist a new display list is created using the glGenLists method. The list definition is started with the glNewList method and the definition is finalized with the glEndList method.
This function will simply loop through each side of the torus and generate a “ring” that loops a full circle (
) around the torus body.
As shown in the image, the “sides” of the torus wrap around the outside of the torus (shown by the magenta ring on the torus body. The “rings” wrap around the inside of the torus body (show by the red ring on the torus loop).
For each step on the torus, a vertex of the torus is plotted using the TorusVertx inline function.
// Plot a single vertex of the torus inline void TorusVertx( float u, float v, float innerRadius, float outerRadius ) { static const float sTexCoord[3] = { 0.5, 0, 0 }; static const float tTexCoord[3] = { 0, 0.5, 0 }; float x, y, z, s, t; float cu, su, cv, sv; cu = cosf( u ); su = sinf( u ); cv = cosf( v ); sv = sinf( v ); x = ( outerRadius + innerRadius * cv ) * cu; y = ( outerRadius + innerRadius * cv ) * su; z = innerRadius * sv; // Object planar texture mapping s = ( x * sTexCoord[0] ) + ( y * sTexCoord[1] ) + ( z * sTexCoord[2] ); t = ( x * tTexCoord[0] ) + ( y * tTexCoord[1] ) + ( z * tTexCoord[2] ); // Spherical texture mapping //float length = sqrtf( x * x + y * y + z * z ); //s = ( x / length ) * sTexCoord[0] + ( y / length ) * sTexCoord[1] + ( z / length ) * sTexCoord[2]; //t = ( x / length ) * tTexCoord[0] + ( y / length ) * tTexCoord[1] + ( z / length ) * tTexCoord[2]; glTexCoord2f( s, t ); glNormal3f( cu * cv, su * cv, sv ); glVertex3f( x, y, z ); }
This function is based on the parametric equation of a torus:
Where,
are in the interval
.
is the outer radius of the torus (indicated by the magenta line in the torus image above).
is the inner radius of the torus (indicated by the red line in the torus image above).
The texture coordinate is determined from a object-planar texture coordinate generation where the x, y, and z components of the position are directly mapped to the texture coordinate. The sTexCoord and tTexCoord static constant arrays determine the axis and scaling of the texture coordinates.
To enable spherical texture coordinate mapping, un-comment lines 142-144.
The LoadResources Method
The LoadResources method is used to load any textures or geometry that is used by the application. Texture loading is a large topic in itself, but I’m using the “Simple OpenGL Image Library” (SOIL) to simplify the image loading. SOIL can be used to load standard texture formats as well as cube maps. brushed metal texture for the reflection material g_BrushedMetalTexture = SOIL_load_OGL_texture( "Resources/Textures/brushed-metal.jpg", SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_FLAG_MIPMAPS ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT ); // Load a glass texture for the refractive material g_GlassTexture = SOIL_load_OGL_texture( "Resources/Textures/glass-texture-2.jpg", ); }
Our cube map texture that will contain the environment that will be reflected and refracted in our shader is stored in the g_EnvCubeMap parameter. The cube map consists of six sides. The sides are named with the assumption that the cube map is rendered at the center of the viewer and the sides are relative to the axis of the world with no rotation.
- The North side is the side that is in the positive Z axis.
- The South side is the side that is in the negative Z axis.
- The East side is the side that is in the positive X axis.
- The West side is the side that is in the negative X axis.
- The Up side is the side that is in the positive Y axis.
- The Down side is the size that is in the negative Y axis.
On line 96, and 97 the cube map’s texture wrapping mode is set to GL_CLAMP_TO_EDGE. This reduces the appearance of seams at the edge of the cube map.
Two 2D textures are also loaded. These texture are applied to the torus’s and we want the textures to repeat if the texture coordinate gets out of the range 0 to 1.
When we load a texture using SOIL, it keeps the texture bound to the first texture stage. So before we leave the function, we have to unbind the texture so that we don’t accidentally texture something we didn’t mean to texture.
The InitGL Method
We’ll use the InitGL method to initialize the OpenGL states that are used for this demo.
void InitGL() { glClearDepth( 1.0f ); glEnable( GL_DEPTH_TEST ); }
Since we will be drawing the cube map texture over the entire screen, we don’t need to define a clear color. And since we won’t be using any lights (because the fragment shader will be calculating all the colors we will see) we don’t need to initialize any lights or materials or anything of that sort.
We only need to set the value the depth buffer is cleared to and enable depth testing in the rendering pipeline.
The OnEffectLoaded Method
The OnEffectLoaded method is the event callback that gets invoked when an effect has been loaded. All of the effects used in this demo define a cube map sampler called “envSampler”. We’ll query the effect parameter and set the parameter to the value of the cube map texture that was loaded in the LoadResources method.
void OnEffectLoaded( EffectLoadedEventArgs& e ) { // Set the properties for the effects Effect& effect = e.Effect; // All of the effects in this demo have a samplerCUBE parameter called "envSampler". // Query that and assign the cube map to that sampler. EffectParameter& cubeMapParameter = effect.GetParameterByName( "envSampler" ); cubeMapParameter.Set( g_EnvCubeMap ); }
The effect that generated the event is accessible from the event parameters. The “envSampler” parameter is quired from the effect and assigned the environment cube map texture object ID.
That should be everything we need to do to initialize the demo. Let’s now take a look at the update and render methods.
The OnUpdate Method
The OnUpdate method will be used to simply update the angle of rotation that will be used to rotate the tori.
Every two seconds the EffectManager will be asked to check all of it’s loaded effects to see if the effect file has changed on disc. If so, the effect will be reloaded. ); } }
The fAnimTimer variable is used to keep track of how long the animation has been running thus far and the fRotationRate variable is used to control the speed of rotation of the torus objects.
Every two seconds, the EffectManager will check to see if any of the effects have been updated and disc and if so, the effect will be reloaded.
On line 358, the g_fRotatePrimitive is updated based on the fRotationRate variable which will be used later to rotate the primitives before being rendered.
The OnPreRender Method
The OnPreRender method is used to update any effect variables that can be shared with all other effects. The EffectManager defines a few predefined shared parameters and when an effect is loaded all effect parameters that have a semantic that matches the shared parameter semantic will be automatically connected to that shared parameter. 367 and 368 the camera’s view matrix and projection matrix parameters are set. The EffectManager will automatically calculate any matrices that are dependent on the view and projection matrices (including the inverse, transpose, and inverse-transpose versions of those matrices) and if the effect assigns a matrix parameter with a matching semantic, that value will be automatically updated via the shared parameter.
Other shared parameters include the elapsed time since the previous frame, the total time the application has been running, the current position of the mouse, and the current state of the mouse buttons.
The OnRender Method
The OnRender method will render a sky box using the cube map texture that was loaded earlier and it will also render the three tori that demonstrates the reflection, refraction and reflection-refraction effects.
The first thing we’ll do is initialize some parameters and draw the sky box using the cube map we loaded earlier.);
The eye position in world space is derived from the camera’s view matrix and stored in the eyePos variable.
Since the sky box will be overdrawing the entire screen, there is no benefit to clearing the color buffer so on line 420 we only need to clear the depth buffer.
The DrawCubeMap method will draw a sky box around the viewer. If we disable the lighting and disable writing to the depth buffer, we can draw a unit cube around the origin of the model-view matrix using the cube map as a texture for the cube. The effect is view that appears to be infinitely far away from the viewer.
The DrawAxis method will just draw some lines at the origin of the pivot camera’s view. This is useful to align the origin of rotation of our view.
On line 427, we also define a matrix parameter that will be used to position our objects in the world.
Next we’ll draw the three tori. The first torus is a reflective torus with the brushed metal
// Draw a reflective torus { Effect& effect = mgr.GetEffect("C7E1_reflection"); EffectParameter& eyeParameter = effect.GetParameterByName( "gEyePos" ); eyeParameter.Set( eyePos ); EffectParameter& baseTextureParam = effect.GetParameterByName( "baseSampler" ); baseTextureParam.Set( g_BrushedMetalTexture );(); } }
First we get the C7E1_reflection that was loaded earlier and set some of the non-shared parameters like the eye position (which could be shared but there is currently no method for determining which space the eye positions should be expressed in) and the base texture of the object.
On line 438 and 439 the world matrix is built that places the torus 6 units to the left of the origin and rotates it about the X axis.
The world matrix is assigned to the EffectManager which ensures that any shared parameters that rely on the world matrix are updated (like the parameter defined with the WORLDVIEWPROJECTION semantic for example).
The EffectManager also defines a series of shared parameters that define the different components of the material that should be applied to the object. On line 442 the reflective material is assigned to the shared parameters that are managed by the EffectManager class.
On line 444, and 445, the effect parameters and shared parameters are sent to the GPU using the EffectManager::UpdateSharedParameters and Effect::UpdateParameters methods.
To render the geometry using the effect, we first need to query the technique that is associated with the effect and for each pass defined in the effect, we render the geometry.
We can render the torus display list using the glCallList OpenGL method passing as a parameter the ID to the torus display list we created earlier.
The next torus will be rendered using the reflection/refraction effect. There isn’t much difference in this code block so I won’t outline each step but I will just highlight the changed code.
// Draw a reflective-refractive torus { Effect& effect = mgr.GetEffect("C7E3_refract_reflect");_ReflectRefractMaterial ); mgr.UpdateSharedParameters(); effect.UpdateParameters(); Technique& technique = effect.GetFirstValidTechnique(); foreach( Pass* pass, technique.GetPasses() ) { pass->BeginPass(); glCallList( g_TorusDisplayList ); pass->EndPass(); } }
The only difference here is the effect that is used to render the torus and the world transform of the torus object.
And the third torus is rendered using a purly refractive shader.
// Draw a refractive torus { Effect& effect = mgr.GetEffect("C7E3_refraction");_RefractiveMaterial ); mgr.UpdateSharedParameters(); effect.UpdateParameters(); Technique& technique = effect.GetFirstValidTechnique(); foreach( Pass* pass, technique.GetPasses() ) { pass->BeginPass(); glCallList( g_TorusDisplayList ); pass->EndPass(); } }
Again, very little change from the previous object except the effect that is used to render the torus and the world transform of the object.
And finally, to swap the front and back render buffers and present the view we need to inform the application to present the back buffer.
g_App.Present(); }
Now we’ve seen the application side of rendering our scene. Let’s take a look at the shader effect files.
The Shader Effects
This demo uses three different shaders.
- C7E1_reflection.cgfx: A reflection shader.
- C7E3_refraction.cgfx: A refraction shader.
- C7E3_refract_reflect.cgfx: A combination of refraction and reflection effect.
The Reflection Shader
The reflection shader works by calculating an incident vector (
) which is the vector from the viewer (the eye position) to the point we are shading. The incident vector is reflected from the surface we are shading about the surface normal (
) at the point we are shading.
In the image above, the red vector represents the incident vector (
) which is the vector from the viewer to the point we are shading. The green vector represents the surface normal (
) at the point we are shading. The yellow vector is the projection of
onto
and is computed by scaling the surface normal
by the dot product of
and
. The blue vector (
) is computed by subtracting the yellow vector twice from
.
If we make the following definitions:
is the world position of the point we are shading.
is the world position of the camera (or eye position).
Then the general formula for calculating the reflection vector is:
Fortunately, you don’t have to compute this reflection vector yourself in the shader program because Cg provides the reflect function to you.
- float3 reflect( I, N ): Returns the reflected vector (
) from an incoming incident ray (
) and the surface normal (
). The resulting vector has the same length as
.
Now let’s take a look at the shader code.
The Vertex Program
The reflection vector is computed per-vertex instead of per-fragment. There is nothing preventing you from moving the reflection calculation to the fragment program but the difference in quality in doing the reflection calculation per-fragment might not be very noticeable if your model is highly tessellated.
First lets define a few global structs and parameters.
struct Material { float4 Ke : EMISSIVE; float4 Ka : AMBIENT; float4 Kd : DIFFUSE; float4 Ks : SPECULAR; float shininess : SPECULARPOWER; float reflection : REFLECTION; float refraction : REFRACTION; float transmittance : TRANSMITTANCE; }; texture baseTexture; sampler2D baseSampler = sampler_state { Texture = <baseTexture>; MinFilter = Linear; MagFilter = Linear; };3 gEyePos; Material gMaterial;
For this demo, I’ve added the reflection, refraction, and transmittance parameters to the material struct. For reflection, only the reflection parameter is used and it is a scalar value in the range 0 to 1 which indicates the intensity of the reflection. A value of 0 means the material is not reflective at all while a value of 1 indicates the material is completely reflective.
The baseSampler parameter is used to apply a diffuse texture to the object and the envSampler parameter is used to store the cube map that is used as the environment sampler that will be applied to the objects. These parameters were set in the application before the objects are rendered.
And we also need to store the matrices that are used to transform our object space position into clip space and world space.
The gEyePos vector defines the position of the viewer in world space.
// This is C7E1v_reflection from "The Cg Tutorial" (Addison-Wesley, ISBN // 0321194969) by Randima Fernando and Mark J. Kilgard. See page 177.); }
The incoming parameters supplied by the application are the position parameter with the POSITION semantic, the texCoord parameter with the TEXCOORD0 semantic, and the normal with the NORMAL semantic.
The out parameters which are passed to the fragment progarm are the oTexCoord parameter with TEXCOORD0 semantic and the reflection vector R parameter with TEXCOORD1 semantic.
The oPosition parameter with POSITION semantic is clip-space position of the vertex and it must be computed in the vertex program but it is not bound to any input parameter in the fragment program.
On line 48, the vertex position is transformed from object space to clip space by multiplying the vertex position by the world, view, projection matrix. The texture coordinate is imply passed-through to the fragment program.
On lines 52, and 53 the world-space position and surface normal is computed by multiplying by the world matrix of the object. This is a necessary step before the reflection vector can be computed because the reflection vector must be accurately computed in world-space. This is a requirement for the cube map texture sampler that the (direction) vector that is used is expressed in the same space as the map is defined.
On line 57 the incident direction vector is computed and passed to the reflect function to produce the reflection vector.
The Fragment Program
The only responsibility of the fragment program is to sample the base texture and the cube map and compute the final color of the fragment based on the amount of reflection defined in the material.
// This is C7E2f_reflection from "The Cg Tutorial" (Addison-Wesley, ISBN // 0321194969) by Randima Fernando and Mark J. Kilgard. See page 180. void C7E2f_reflection(float2 texCoord : TEXCOORD0, float3 R : TEXCOORD1, out float4 color : COLOR, uniform Material material,, material.reflection); }
The first two parameters texCoord and R are input parameters passed from the vertex shader.
The only output parameter that the fragment program must compute is the color parameter with the COLOR semantic. This is the final color that will be blended with the current fragment in the framebuffer.
On line 73 the environment map is sampled passing the reflection vector R as the second parameter. This direction vector does not need to be normalized before it is used in a cube sampler.
On line 76, the base texture is sampled using the texture coordinate passed from the vertex program.
The final color is a linear interpolation between the base texture and the value of the cube map in the direction R based on the reflection parameter defined in the Material struct. If the reflection parameter is 0, then only the decalColor will be visible and if the reflection parameter is 1, then only the reflectedColor will be visible.
Techniques and Passes
Each effect only defines a single technique with a single pass.
technique main { pass p0 { VertexProgram = compile latest C7E1v_reflection( gEyePos, gModelViewProj, gModelToWorld ); FragmentProgram = compile latest C7E2f_reflection( gMaterial, baseSampler, envSampler ); } }
We define the VertexProgram and the FragmentProgarm by telling Cg to compile the two entry points for each program using the latest platform supported.
Now let’s take a look at refraction.
The Refraction Shader
Refraction occurs when light enters a medium that has a different density than the medium the light originated from. For example, when light passes through glass, the light will appear to “bend” at the boundary of the two mediums (air, and glass).
Refraction is defined by Snell’s law which states that the ratio of the sines of the angles of incidence and refraction is equivalent to the ratio of phase velocities in the two media, or equivalent to the opposite ratio of the indices of refraction.
If we define the following:
and
are the wave velocities in the separate media.
and
are the refractive indices of the two medium.
Then,
Fortunately, we don’t have to worry too much about how the refraction is calculated because Cg provides the refract function to calculate the refractive vector.
- float3 refract( float3 i, float3 n, float eta ): Computes the refraction vector from the incident ray i, the surface normal n and the ratio of the indices of refraction between the two medium (eta). The incident vector (i) and the surface normal (n) should be normalized.
Although it is the discretion of the vendor regarding how this method is implemented, but it is possible that this method is implemented in this way:); }
The Vertex Program
The only difference between the reflection shader and the refraction shader is the computation of the direction vector that is passed to the fragment program.
// This is C7E3v_refraction from "The Cg Tutorial" (Addison-Wesley, ISBN // 0321194969) by Randima Fernando and Mark J. Kilgard. See page 187. void C7E3v_refraction(float4 position : POSITION, float2 texCoord : TEXCOORD0, float3 normal : NORMAL, out float4 oPosition : POSITION, out float2 oTexCoord : TEXCOORD0, out float3 T : TEXCOORD1, uniform Material material,, material.refraction); }
On lines 58 and 59 the refract vector is computed from the normalized incident vector and the surface normal and the ratio of indices of refraction.
A table of refractive indices can be found at.
Air at sea-level has an index of refraction of 1.000277 and water at room temperature has an index of refraction of 1.333. So the if the incident vector (I) is going from air to water, the ratio of the indicies would be:
Different types of glass have different index of refraction values but generally a good index of refraction for glass is 1.5. So the ratio between air and glass would be:
And this is the value that is used for the refraction parameter.
The Fragment Program
The fragment program for the refractive texture is also almost identical to that of the reflection program. The only difference is that instead of using the material’s reflect parameter, the transmittance value determines how much of the light is transmitted through the object. You may have noticed that the amount of light that passes through a medium changes with the thickness of the material. We are not concerned with dispersion and attenuation factors in this simple shader program so this is something that you can investigate for yourself.
// This is C7E4f_refraction from "The Cg Tutorial" (Addison-Wesley, ISBN // 0321194969) by Randima Fernando and Mark J. Kilgard. See page 188. void C7E4f_refraction(float2 texCoord : TEXCOORD0, float3 T : TEXCOORD1, out float4 color : COLOR, uniform Material material,, material.transmittance); }
If the transmittance value is 0, then no light is transmitted through the material and only the base texture is visible. If the transmittance value is 1, then the material is completely transparent and only refracted light is used to color the fragment.
There is one more shader that does both the reflection and refraction effects then blends the final color based on the values of reflection and transmittance parameters but I will leave it up to the reader to implement this.
If everything works well, then the resulting application should look something like this:
References
Download the Source
The source code example for this article can be downloaded from the link below.
It won’t work on my GTX460 🙁 boohoo | https://www.3dgep.com/environment-mapping-with-cg-and-opengl/ | CC-MAIN-2018-05 | en | refinedweb |
public class SanderRossel : Lazy<Person>
{
public void DoWork()
{
throw new NotSupportedException();
}
}
G-Tek wrote:these phishing messages were written with intentionally poor grammar and spelling
MehGerbil wrote:When I see stupid phishing attempts like this I always wonder: "How much money can the people stupid enough to fall for this sort of thing have to steal?"
[Marketers] must run experiments, tag, and track new events all the time. They can’t afford to wait for a developer to tweak a graph in the dashboard. [Marketers] need data, and they need it now.
General News Suggestion Question Bug Answer Joke Praise Rant Admin
Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages. | https://www.codeproject.com/Lounge.aspx?msg=4883242 | CC-MAIN-2018-05 | en | refinedweb |
iImposter Struct ReferenceiImposter defines the interface a mesh (or other) class must implement to be used as imposter mesh by the engine.
More...
[Crystal Space 3D Engine]
#include <iengine/imposter.h>
Detailed DescriptioniImposter defines the interface a mesh (or other) class must implement to be used as imposter mesh by the engine.
Definition at line 39 of file imposter.h.
Member Function Documentation
Camera Rotation Tolerance is the tolerance angle between z->1 vector and object on screen.
Exceeding this value triggers updating of the imposter whenever the object slides too much away from the center of screen..
The documentation for this struct was generated from the following file:
- iengine/imposter.h
Generated for Crystal Space 1.2.1 by doxygen 1.5.3 | http://www.crystalspace3d.org/docs/online/api-1.2/structiImposter.html | CC-MAIN-2016-40 | en | refinedweb |
In the first
article in this series, I introduced the basics of forms authentication
in ASP.NET. By the end of the article, you saw how to use code in a login
page to authenticate users according to whatever custom scheme you like, and how
to use additional code in the
global.asax file to build custom
principal and identity objects to fully identify the application's users and
their roles. The earlier solution, while complete, is a bit unsatisfying.
To reuse the authentication code in more than one application requires cutting and pasting both the login code and the global authentication code. As you know, reuse by cut-and-paste is a dangerous practice; if you discover a bug in your code, you have to run around and fix it everywhere. Surely a modern development environment such as ASP.NET can support a more structured type of reuse. In fact, it can.
In this article I'll tidy up the authentication code by making it possible to reuse both chunks of code, using a web custom-control for the initial login, and a HttpModule to build the identity and principal objects. If you haven't run into these parts of ASP.NET yet, you'll end up with two additional techniques to add to your repertoire, which is always a good thing.
ASP.NET actually offers you four different alternatives for encapsulating chunks of user interface and code together in controls:
Each of these control types has its pros and cons. Web user controls are
extremely easy to create, but they can't be added to the Visual Studio .NET
toolbox. And they require their
.ascx file to be copied to the project where the
controls are used, which puts you right back to cut-and-paste reuse. Composite
custom controls are a good choice when you've got a group of controls that you
want to cart around together. Derived custom controls are best when you want a
new control whose behavior is close to that of a single existing control. And
finally, writing from scratch provides you the most flexibility, at the cost of
doing the most work.
In the case at hand, I'd like to wrap up the labels and textboxes in the login interface (shown in Figure 1) into a single control. A composite custom control is just the ticket for this.
Figure 1. The login user interface.
Creating a composite control in C# starts with create a new Web Control
Library project; I named the project LoginControls, though right at the moment I
don't plan to add more than one control to it. Visual Studio .NET will
automatically create a new
WebControl1.cs file; I renamed this to
LoginControl.cs. Then I went in and gutted it, removing almost all of the
automatically generated code. That's because the C# version of the Web Control
Library project assumes that you're the type of real programmer who always
builds from scratch, and so it includes the scaffolding to create a brand new
control rather than deriving from existing controls. That's nice, but it's also
not what I wanted. Instead, I added this code to wrap the login bits up as a
control:
using System; using System.Web; using System.Web.UI; using System.Web.UI.WebControls; using System.ComponentModel; using System.Security.Principal; using System.Web.Security; namespace LoginControls { public class LoginControl : Control, INamingContainer { // Controls that make up the composite control Label lblUserName; TextBox txtUserName; Label lblPassword; TextBox txtPassword; Button btnAuthenticate; // Will be called by ASP.NET when it's time to render // the composite control protected override void CreateChildControls() { // Create the constituent controls lblUserName = new Label(); txtUserName = new TextBox(); lblPassword = new Label(); txtPassword = new TextBox(); btnAuthenticate = new Button(); // Set properties lblUserName.Text = "User Name"; lblPassword.Text = "Password"; txtPassword.TextMode = TextBoxMode.Password; btnAuthenticate.Text = "Authenticate Me"; // Add to the controls collection, together // with the necessary HTML goop Controls.Add(lblUserName); Controls.Add(new LiteralControl(" ")); Controls.Add(txtUserName); Controls.Add(new LiteralControl("<br>")); Controls.Add(lblPassword); Controls.Add(new LiteralControl(" ")); Controls.Add(txtPassword); Controls.Add(new LiteralControl("<br>")); Controls.Add(btnAuthenticate); // Attach an event handler btnAuthenticate.Click += new EventHandler(btnAuthenticateClick); } // Handle the click event for the button public void btnAuthenticateClick); Context.Response.Cookies.Add(faCookie); // And send the user where they were heading Context.Response.Redirect(FormsAuthentication.GetRedirectUrl( txtUserName.Text, false)); } } } }
The composite control code is really pretty simple. The key procedure here is
CreateChildControls, which gets called when it's time to render the
control at runtime. As you can see, I use this procedure to create the controls
that make up my user interface, set some properties, and then add them to the
Controls collection. Note the use of the
LiteralControl class to
insert some HTML markup between the individual textboxes and labels. The
code that handles the button's click event is exactly the same code that I
showed you last time. The difference is that this time the code is in the
custom control instead of behind the web form.
Build the new custom control and it's ready to go.
Using the custom control is just about as easy as creating it. To start, load
up the ASP.NET application where you're using forms authentication, and delete
all of the controls and code from the
login.aspx page. Now decide which tab of
the Toolbox should contain the custom control; I chose the Components tab,
mainly because it's relatively uncluttered. Right-click on the tab and select
Add/Remove Items. This will open the Customize Toolbox dialog box. Make sure the
.NET Components tab is selected and click Browse. Locate your custom control's
DLL file, and click Open and then OK. This will add the control to the
Toolbox.
Now you can use the LoginControl just like any other control. In particular,
you can drag and drop it to the
login.aspx page. That's it! You don't have to
write any code; it's all wrapped up in the control now, along with the user
interface. You can run the project at this point to prove to yourself that the login logic is still working.
Packaging the login user interface into a custom control is half the battle.
But what about the code that's in
global.asax. To make this code
more easily reusable, it helps to know something about the ASP.NET pipeline.
When a user requests an ASP.NET page from your server, the request isn't handled
by one monolithic piece of software. Instead, it's passed from program to
program along a virtual pipeline. Each program along the way can do its own bit
of work with the request. Here are the components involved in the pipeline for a
typical ASP.NET web form:
HttpApplication, which takes care of application-level processing. This is where
global.asaxcomes into play.
HttpModuleinstances. These are extensions that handle various chores; for example, caching and state management are handled by system-wide
HttpModuleinstances.
HttpHandlerfor the request. For web forms, this is normally an instance of the
Pageclass.
For the problem at hand, the key point in this chain is the
HttpModule. Any application can specify in its
web.config file a set of
HttpModule classes that
requests should be routed through. By moving the code from
global.asax to a custom
HttpModule, I can make it more
easily available to any application that wants to use it.
An
HttpModule is nothing more than a class that implements
IHttpModule. So to move my custom authentication out of
global.asax, I created a new Class Library project with a single
class named
SetIdentity. Here's the code:
using System; using System.Security.Principal; using System.Web; using System.Web.Security; using System.Diagnostics; namespace AuthModule { public class SetIdentity: IHttpModule { public SetIdentity() { } public void Init(HttpApplication context) { context.AuthenticateRequest += (new EventHandler(this.Application_AuthenticateRequest)); } private void Application_AuthenticateRequest(Object source, EventArgs e) { HttpApplication application = (HttpApplication)source; HttpContext context = application.Context; // Get the authentication cookie string cookieName = FormsAuthentication.FormsCookieName; HttpCookie authCookie = context.Request.Cookies[cookieName];; } public void Dispose() { } } }
Most of the code here is unchanged from what I had in the
global.asax file, but there are a couple of points to note. First,
the
HttpModule can hook into application-level events by adding its
own set of event handlers in the
Init procedure. That's how it
happens that this
HttpModule actually participates in the pipeline.
Second, there's a bit of extra code in the actual event handler to derive the
current context from the
HttpApplication object that gets passed
in.
To hook up the
HttpModule class to an actual application, you
need to do several things. First, of course, compile the code. Second, drop a
copy of the
dll into the application's bin folder. Finally, make an entry in the
web.config file:
<configuration> <system.web> <httpModules> <add name="SetIdentity" type="AuthModule.SetIdentity, AuthModule" /> </httpModules> ... </system.web> </configuration>
With this change made, I can remove the remaining authentication code from
the
global.asax module. Now both halves of the process are in
reusable components. To add authentication to any application, all I need to do
is drop the login control on a form, copy the
HttpModule library to
the project, and make a few changes to the
web.config file.
If you step back to think about the entire journey, from no authentication at all to authentication wrapped up in reusable components, you'll see a pattern that appears over and over in software development. Faced with a problem (such as authenticating users to a web site), just about any developer can do the research to come up with a solution. The good developer will remember the solution the next time she's faced with a similar problem, and know which project contains the code that can be reused. The really good developer will spend the extra time to think about reuse explicitly, and to build as much of the solution as possible with an eye toward future reuse. By doing that little bit of extra work, you'll save a lot of effort in the future.
Mike Gunderloy is the lead developer for Larkware and author of numerous books and articles on programming topics.
Return to ONDotnet.com. | http://archive.oreilly.com/lpt/a/4621 | CC-MAIN-2016-40 | en | refinedweb |
way too much random noise in the headspace this weekend. On
Thursday I decided I'd try to fix a bug(?) in g++
that causes __builtin_*
functions to cause ambiguity at global scope, even when they
were
declared/requested within a namespace. Bad Idea. Wasted a
weekend.
I _think_ I see the general area(s) where the eventual fix
will
be, but
the 3 hour compiler compile has kept me from randomly
editing the
compiler's source :) I gave the problem all of the spare
cycles I had,
yet was unable to solve it (eek eek). Now, I must wait til
next weekend
to fight it again. I _really hope_ someone produces a
solution to the
problem so [1) I don't waste another weekend and [2) I can
see
how
the problem was solved for future bug hunting fun ;-)
On top of this, I had to make a decision to decline a job
offer I
received on Friday. In fact, I think making this decision
slowed
down the bug-hunting substantially -- damn distractions! I'm
still
not comfortable in declining the job, since there would have
been a
$10k salary increase in addition to 10k stock options, but
there is
_no way_ I can leave my current employer (who would have a
really
bad time if I left) on such short notice. This little dilema
started me
thinking that the general shortage of skilled workers might
make
an 'employee swap' for employers a very useful/profitable
business.
Well, this is only useful if the employer and employee
actually like
each other. I drink beer with my boss on occasion, and would
hate
to lose a friend over a silly employment issue.
Oh yeah, I also decided to wipe out a well-aged debian
system
and install debian 2.2. I'm gonna _try_ to _not_
un-debianize the
box this time. I spent two hours trying to figure out how to
upgrade
a package the debian way when it would have take 15 minutes
to
download the tarball and configure/make/make install, but I
did
the debian thing :), and _hope_ to keep this system a debian
system
instead of turning it into a Brent's Linux Non-Distro. This
experience
reminded me how much simpler FreeBSD's ports system is to
use. | http://www.advogato.org/person/nomadamon/diary.html?start=1 | CC-MAIN-2016-40 | en | refinedweb |
#include "petscmat.h" PetscErrorCode MatCreateMPIAIJWithSplitArrays(MPI_Comm comm,PetscInt m,PetscInt n,PetscInt M,PetscInt N,PetscInt i[],PetscInt j[],PetscScalar a[],PetscInt oi[], PetscInt oj[],PetscScalar oa[],Mat *mat)Collective on MPI_Comm
The i and j indices are 0 based
See MatCreateAIJ() for the definition of "diagonal" and "off-diagonal" portion of the matrix
This sets local rows and cannot be used to set off-processor values.
Use of this routine is discouraged because it is inflexible and cumbersome to use. It is extremely rare that a legacy application natively assembles into exactly this split format. The code to do so is nontrivial and does not easily support in-place reassembly. It is recommended to use MatSetValues() (or a variant thereof) because the resulting assembly is easier to implement, will work with any matrix format, and the user does not have to keep track of the underlying array. Use MatSetOption(A,MAT_IGNORE_OFF_PROC_ENTRIES,PETSC_TRUE) to disable all communication if it is known that only local entries will be set.
Level:advanced
Location:src/mat/impls/aij/mpi/mpiaij.c
Index of all Mat routines
Table of Contents for all manual pages
Index of all manual pages | http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/Mat/MatCreateMPIAIJWithSplitArrays.html | CC-MAIN-2016-40 | en | refinedweb |
This method compiles an
XPathExpression which can then be used for (repeated) evaluations.
Syntax
xpathExpr = document.createExpression(xpathText, namespaceURLMapper);
Parameters
- String
xpathText(the XPath expression to be compiled)
- Function
namespaceURLMapper(maps a namespace prefix to a namespace URL (or null if none needed))
Prior to Firefox 3, you could call this method on documents other than the one you planned to run the XPath against. Under Firefox 3, you must call it on the same document. | https://developer.mozilla.org/en-US/docs/Web/API/Document/createExpression | CC-MAIN-2016-40 | en | refinedweb |
require exporter;
export = qw (functions, $variables, @arrays);
[download]
$dbh = $dbi->connect(...)
$variable2= $something2->othermethod();
[download]
$variable2= $something2->othermethod($dbh,...);
[download]
I'm not sure exactly what you're looking for. "Inheritance" is a term specific to object oriented programming that describes one way to say "This thing acts like this other thing, perhaps with some small changes."
Inheritance may be one way to solve what you're doing here, but I don't think it is.
You have a couple of options for making one variable or object available across multiple modules:
There are other options, but they're mostly variants of these strategies. I do suggest modularizing your code by behavior and duty, though. It has many other benefits.
To export something from a module you need to use:
use Exporter; # require works;
@ISA = 'Exporter';
@EXPORT_OK = qw(functions $variables @arrays);
# I put this after the above, some put this above and then use "our".
use strict;
[download]
What you wrote, by contrast, has several syntax errors, forgets that Perl is case-sensitive, and has some more subtle mistakes (eg the , inside of qw()). One of the more subtle mistakes is choosing to use @EXPORT instead of @EXPORT_OK, which works, but which will make debugging much harder. (Where did this come from?)
As for the question that you're asking, the simple way to do it is to use fully qualified package names. Like this:
# In the main script...
use strict;
use vars qw($foo);
# ... time passes ...
$foo = "whatever";
# In the module...
print $main::foo;
[download]
PS: Note that I've pushed you towards using strict.pm. There are good reasons for that...
This is not related to debugging.
The difference is that subs and vars included in @EXPORT will always be exported to the modules use'ing the module, while on the other hand, things included on @EXPORT_OK will only be exported when explicitely requested on the use statement.
The problem with @EXPORT is namespace pollution that leads to name collisions when exported functions are added in new versions of some module.
The first debugging problem is figuring out what happened after name collisions. (Creating bugs leads to debugging...) The second, and to me more important, one is the added trouble in finding the functions and variables that you see being called and accessed.
The difference is that subs and vars included in @EXPORT will always be exported to the modules use'ing the module...
Not to be overly retentive here, but that's not quite right. Or at least not sufficiently clear. In the empty list case -
use Some::Module ();
- no symbols are exported, even the ones in @EXPORT. In fact, @EXPORT are only imported in the default (unspecified) case. If you specify your imports explicitly, then you only get what you ask. | http://www.perlmonks.org/?node=inheritance | CC-MAIN-2016-40 | en | refinedweb |
XMonad.Layout.ImageButtonDecoration
Description
A decoration that includes small image
- imageButtonDeco :: (Eq a, Shrinker s) => s -> Theme -> l a -> ModifiedLayout (Decoration ImageButtonDecoration s) l a
- defaultThemeWithImageButtons :: Theme
- imageTitleBarButtonHandler :: Window -> Int -> Int -> X Bool
- data ImageButtonDecoration a
Usage:
You can use this module with the following in your
~/.xmonad/xmonad.hs:
import XMonad.Layout.ImageButtonDecoration
Then edit your
layoutHook by adding the ImageButtonDecoration to
your layout:
myL = imageButtonDeco shrinkText defaultThemeWithImageButtons (layoutHook defaultConfig) main = xmonad defaultConfig { layoutHook = myL }
imageButtonDeco :: (Eq a, Shrinker s) => s -> Theme -> l a -> ModifiedLayout (Decoration ImageButtonDecoration s) l aSource
imageTitleBarButtonHandler :: Window -> Int -> Int -> X BoolSource
A function intended to be plugged into the
decorationCatchClicksHook of a decoration.
It will intercept clicks on the buttons of the decoration and invoke the associated action.
To actually see the buttons, you will need to use a theme that includes them.
See
defaultThemeWithImageButtons below.
data ImageButtonDecoration a Source
Instances | http://hackage.haskell.org/package/xmonad-contrib-0.11.3/docs/XMonad-Layout-ImageButtonDecoration.html | CC-MAIN-2016-40 | en | refinedweb |
Bin ary an outsider may have a superficial understanding of indigenous phenomena found in other cultures, he or she may point out peculiar- ities. Annual deaths attributable to obesity in the United States. However, findings from other binary options bank de swiss have yielded contradictory results, and scal ping relationships bnary behavior, psychosocial stressors, immune status, and HIV pro- gression apparently exist, these relationships are not completely scalping.
1 Cortical connections between homotopic points of the two hemispheres are severed. Thus, the results of sodium amobarbital testing support the results of lesion studies in confirming a special role for the left hemisphere in the control of movement.
The applet uses getAppletContext( ). 50). Brackbill studied a similar child f orex found that, in re- sponse to moderately loud sounds (6090 decibels), this in- fant oriented to stimuli in much the same way as normal infants do. 105. As with other legal competencies, testamentary ca- pacity does not hinge on the mere presence or absence of mental disorder.
This fact has important implications for rape prevention efforts. The column is then eluted with12 mL buffer Mbuffer K containing 50 mM NaCl and 150 mM imidazole, the important point here is that regard- less of gender, a strong coach-created performance motivational climate is related to low moral function- ing, inappropriate behavior is judged to be appropri- ate, and players have lower moral reasoning, have a higher intention to cheat, and actually do cheat more.
Originally designed for use with expository text in content area textbooks, 2000. This fact-together with the effects noted in esophageal, gastric, and mammary carcinogenesis (Table 8. Forex scalping binary options combo method investigations have forex scalping binary options combo method the amine hormones serotonin and dopamine as playing significant roles in the mech- anism of the anorexia of cancer.
Using picks and small explosives, in turn, has Page 399 380 SCHIZOPHRENIA implications for prevention forex scalping binary options combo method the need to search as vigorously for factors that protect from illness as for those that encourage it. 14) L 1 1 Tj Q where Q is the total heat flow and is constant.
Binary option trading brokers in india Its constructor uses super to pass the binary option quebec of the button to the superclass constructor. They also suggest that memories formed early in Page 466 life-say, in the first 20 years or so-may be spared by hippocampal lesions but may be lost if the lesions forx into structures surrounding the hippocampus.
164 co mbo. 640 Values forex scalping binary options combo method Culture This article has emphasized the importance of studying values both at the level of individuals and at the aggregated level of nations. The dual-identity model developed by Gaertner and colleagues takes this idea as a starting point as it aims to maximize the benefits of both the common binry identity and the mutual intergroup differentiation model.
Leadership proved to be an important variable, and binaary models of it have been devised to explain empirical data.
Second, 1972. As an example, professional soccer has what is termed the professional foul where players will sometimes pull an opponents shirt to prevent or hinder progress with the ball. Consequently the spectrum concept forex scalping binary options combo method is irremediably trading binary options with moving averages. Bretz, the seven forex binary options 101 and processes of OD practice are as follows 1.Bartels R.
getY(); flicker true; Chapter Optiгns Images Binary option trading philippines THE JAVA LIBRARY Page 840 810 JavaTM 2 The Complete Reference repaint(); } }); } public void paint(Graphics g) { Graphics screengc null; if (!flicker) { screengc g; g buffer.
When an event occurs, M.Jones P. Method 3 1 Cesmm chloride-banded and PBS-dialyzed recombinant adenovuus encoding active rlbozyme agamst c-myb mRNA (see Note 1). Nutr. Mollon. A binary options trading brokers review belief is that women are cognitively and psychologically ill prepared to become leaders in the business world.18306360, 1997.
; mε0 q2 P dv 1 (vvmin) forex scalping binary options combo method f(v) mε0 (v vmin)2 mε0 (v vmin)2 2 in forex scalping binary options combo method methodd line advantage has been forex scalping binary options combo method of the fact that the imaginary part is zero by assumption, and in the third ьptions the P for principle part has been dropped because there is no longer a singularity at binary trading warning vmin.
Figure 12.Moulthrop M. Who Are the Victims. The script went on to guide participants through a detailed scenario in which they would break the window with their hand and get cut and bloody. link, methodd Forex scalping binary options combo method } public class MyMouseMotionAdapter extends MouseMotionAdapter { public void mouseMoved(MouseEvent me) { mouse_inside_applet true; showStatus(billboardscurrent_billboard.
Uslenghi (1969), Electromagnetic and Acoustic Scattering by Simple Shapes, Amsterdam.Doyle M. Psychological and Behavioral Interventions 5.
(1995). Elements of a list can be accessed through iterators. 5 in prepubertal children. As a semantic example, the biological classifi- cation system can be put into this progressive form as follows species genus genus family family order order class, etc. Then what. 4) are also some of the more obvious ones. Similarly, the cancer risk of potential human exposure to pPAHs at combbo BRS1 and BRS2 site were forrex as additional lifetime cancer risk due to road traffic.
On the other hand, Middle Easterners also have come to the United States to escape an unpopular dictator, but during recent times, Americans have become more hostile, rather than less hostile. Some of its constructors are shown here JScrollPane(Component comp) JScrollPane(int vsb, int hsb) JScrollPane(Component comp, int vsb, int hsb) Here, comp is the component to be added to the scroll pane.
(1992). When it comes to environments such as space travel, balloon exploration, and experimental laboratories that simulate space f orex, no one has any trouble calling these extreme.
Yet the humidity combined with a fairly high temperature makes activity uncomfortable and can pro- duce heat exhaustion and heat stroke under certain conditions. Kelman, H. Binary option by Vector Space Methods. A practical guide binary options truth the use of response forex scalping binary options combo method in social psychological research.
Chassisconstructionandpainting 2Tubularsteel,whichresemblessquare World markets binary options edgesbeveled(cutatanangleoflessthan90 degrees)topreparethemforwelding. Although realistic binary options trade signals regarding weight loss may increase maintenance rates, convinc- ing obese individuals to engage op tions treatment for min- imal losses will undoubtedly prove to be difficult.
) Addendum 3 mol. One source of evidence that the frontal lobe plays a role in corollary discharge comes from the results of studies of cells in the frontal eye fields. Statistical tests (e. It involves learning about forex scalping binary options combo method environment.
1527. The fact that the basic equation of motion in quantum mechanics involves only the first time-derivative of something while the corresponding equation in Newtonian mechanics involves the second time-derivative of some key variable is a very interesting and significant difference.
Conservation of momentum Examination of momentum conservation requires taking the first moment of Eq. Emerging research centers on cognitive and affective models of team motivation, the forex scalping binary options combo method of team- building interventions, task interdependence and per- formance including knowledge structures, and highly pragmatically important issues of team creation, team- building, and performance improvement attempts.
takeOut( ) gets a single letter permanently out combo the shared bag. Programs for Reducing Prejudice and Discrimination in Educational and Employment Settings Further Reading GLOSSARY discrimination Negative behavior toward members of a social group based on group membership.
But there is more to connectivity than the interhemi- spheric connections; there are also intrahemispheric connections.
This article has provided a forex scalping binary options combo method of potential reasons for this enthusiastic foerx and has shown that they are consistent in yielding illusory support.
internic. 200, Combг, 50, 25, 12. Culture and Aggression Contexts for Exercising Coercive Control 2. Early Work in Organizational Settings Best binary option trading platform societies have created all sorts of organizations in which the principles of impersonal work, labor divi- sion.
At a meeting of the British Society of Psychology, Shapiro presented an important work developed in the Maudsley Hospital. Println("Notepad returned " p. Page Methтd 316 Chapter 8 Block, G. An appealing approach for economic csalping could also be the development of an evidence-based disease management programme for schizophrenia in which patient care with all medical resources across the entire health care delivery system are combined and integrated with best evidence, bullying was considered to be physical binary option forex of aggression that primarily occurred between boys.
Asthecoolantisuseditisconta- minatedwithtrampoil,lubricantthatleaks outofmachines. Natl. 52) gives 00 df -Jzikixeikixx - 2kzzeikixx x f( I -w dk ik eikxx)(k ) - 0 x- (9. Engl.
772352 - 0. 22) Binary options minimum trade R3 R4 R1 R3 R4 Now, the following matrix form can be written from the above equations 1111 R1R2R2 R1 (2. Behavioral Endocrinology. Kemegther, L. We will restrict forex consideration binary options strategy org to the most commonly observed disorders.You, M.
Binray to visual elements can also apply to other modalities (e. The following code prints the number 8 on the screen. 0) (see Note 9). However, the number of studies investigating the impact of psychosocial inter- ventions on the immune system is increasing.
Issues and Strategies Further Reading GLOSSARY Big Five A set of personality optio ns (extroversion or energy, agreeableness or friendliness, conscientiousness, emotional optiтns or neuroticism, and openness to expe- rience) considered by forex scalping binary options combo method to be present, to varying degrees, in every individual.
Develop and disseminate policies on cheating. Daly, M. 2Od) (3. The following are the correlations between system parameters and types of interactions skills training-sensorimotor binary options no deposit bonus 2013, attention, and memory; diagnosis-identification of problem areas, individual binary trading accounts, and preferences; scalpnig personal competence and autonomy; and enjoyment-enhancing emotional well-being.
The results also found patterns that support the rationale and implications of CEM. Radon in homes and other technologically enhanced radioactivity. The target must be willing to use the alterna- tive responses because some may be proscribed by socia- lization or normatively sanctioned by proximal social groups.
And Allison, B. Dwyer, K. Adding the particular and low risk binary options strategy solutions together gives the general o ptions v ̃1 ikv0v Forex scalping binary options combo method 0 t (14. On substituting the given parameter binary options trading legal us into Equation 4.
11 and1. Manning, I have argued, be related to the speciation character- istic, the capacity for language. Neu- rovirol. Neurology 189598, 1968. Plomin, W. We have briefly introduced the two major types of compression algorithms lossless compression and lossy compression. s1 s s(s Csalping 121. The same act (i. Hlth Technol. 3 30 Scalpin g solution 1X buffer A, 13502513, 1999.
GrabPixels( ) is defined like this boolean grabPixels( ) throws InterruptedException boolean grabPixels(long milliseconds) throws InterruptedException Both methods return true methьd successful and false otherwise.
Athletes must acquire the skill of adopting the appropriate attentional width and trading binary options strategies and tactics abe cofnas pdf that enables them to make effective decisions. If the natural ordering is used for this set, the U.
To illustrate, a soccer goalkeeper who is preparing to catch a corner kick binary options system review focus only on the flight of the ball while ignoring the potentially distracting move- ments of other players in the penalty area.
We decompose the intensity into reduced intensity and diffuse intensity IuI zu I(jIp (8. The mentor and prote ́ge ́ both benefit from the fьrex and develop a stronger connection.
And the number of bytes required to represent multimedia data optiрns be huge. Binary options brokers free demo account, her romantic advances toward her husband may be what her opttions always wanted.
The movie Shine is an example of the successful use of op tions entertain- ment medium to heighten awareness and communicate information about mental illness.
The following are the methods meth od control this behavior void setDisabledIcon(Icon di) void setPressedIcon(Icon pi) void setSelectedIcon(Icon si) void setRolloverIcon(Icon ri) Here, di, pi, si, and ri are the icons to be used for these different conditions. Page 25 Hairpin Rlbozyme Catalytic RNA Loop site of cleavage l e.3 mm Forex scalping binary options combo method. StaffCaregiver Training binayr Management Staff training programs can take many forms and focus on any of the interventions outlined previously.
Get(Calendar. idList is used to display available opponents.Sun, J. The program forex binary options demo account running and then stops at the first break point it encounters. Thehandlebarisattached,and controlcablesaresecuredandset. Althoughsome typesoftilerequireatwo-stepfiring scalpig once,attemperaturesof2,000 degresFahrenheitormore. Nonetheless, B. 2, they then diverge in fol- lowing the implications of this for different resources, namely, directed attention capacity versus physiologi- cal response capabilities.
Rawls, Churchman and Sadan also identify and discuss a number of factors that may bedevil the effective implementation of participatory processes in the envi- ronmental domain. Annals of Neurology 29315319, as pointed out ofrex Cancro and Meyerson, and all manifestations of mental illness have the capacity to have an impact on the patients adaptation. Cognitive processes are inferred from self-reported rankings.
Despite the advances represented by binary options bully trading system antipsychotic comob, there is a great deal that cтmbo do not know about how to optimize pharmacotherapies. Higher-Level Visual Processes Two cases described by Campbell and colleagues illustrate an intriguing disso- ciation forex scalping binary options combo method visual functions.
Activity that fits these criteria can be observed how do binary option sites make money the human life span. Rhee, employees may perceive themselves as being promoted due to their sexual attractiveness rather than binary options brokers in uae competence.
Behavioral Neuroscience 100337342, D. This effectiveness should be established in patients in whom these symptoms are not secondary to met hod symptomatology. People may live, and even thrive, for years cтmbo even decades with partial deprivation of some physical needs.Binary options forex trading systems | http://newtimepromo.ru/forex-scalping-binary-options-combo-method-2.html | CC-MAIN-2016-40 | en | refinedweb |
Write a program that accepts temperatures from the user, and also whether the temperature is in Fahrenheit,
Celsius or Kelvin (use the following screen shots as a guide). Keep track of the total temperature in Kelvin
and report the total after each user entry as shown below. When the user decides to stop entering information,
display the message "Goodbye!" as shown. You will need to know the following conversions:
[K] = ([F] + 459.67) 5D 9 [K] = [C] + 273.15.
I cannot figure this out for the life of me. Please help me with the code, not just a tip on what the function or whatever is called to fix it, I am very lost. Thanks.
#include <iostream> #include <string> using namespace std; int main() { double temperature; int m,cont; int counter=0,temp,measurement; do { counter=counter+temperature; if (temperature="") cout<<"Please enter a temperature: "; cin>>temperature; if (m="") cout<<"(F)ahrenheit, (C)elsius, or (K)elvin? "; cin>>m; cout<<"Your current total temperature is "<<temperature<< "degrees Kelvin."<<endl; if (cont="") cout<<"Do you want to continue (Y/N)?"; getline(cin, cont); if ((temp=='F')||(temp=='C')||(temp=='K')) m=temp; else cout<<"Please enter a temperature: "; }while ((cont!='n')||(cont!='N'); cout<<"Goodbye!"; switch(measurement) { case 'F': case 'f': temperature=(temperature+459.67)*(5/9); break; case 'C': case 'c': temperature=temperature+273.15; break; case 'K': case 'k': temperature=temperature; } } | http://www.dreamincode.net/forums/topic/102485-do-while-loop-and-switch-case/ | CC-MAIN-2016-40 | en | refinedweb |
How smart must a Java programmer be?
Here's an example. Below is one of the exercises in Richard Baldwin's introductory online Java course. Part 1 is easy, but I found Part 2 very difficult. I usually have to read sentences like that in Part 2 several times before I understand them. I know what all of the elements (parameters, instantiation, etc.)of this problem are, but I still find this difficult. Please be honest. How hard should this be for someone who will do well at programming?
***********************
Q - Write a Java program that meets the following specifications.
/*File SampProg18.java from lesson 42
Without viewing the solution that follows, write a Java
application that illustrates:
1. Instantiating an object by calling the default
constructor.
2. Instantiating an object by calling a parameterized
constructor as a parameter to a function call.
The program should display the following output:
Starting Program
Object contains 100
Terminating, Baldwin
************************
You can find this problem at
Is there a reliable programming aptitude test one can take online?
As a start to an unscientific survey, I'd be interested to know how difficult you find Part 2 of the question above. If you're interested, try to solve it, then go to the URL in my previous post to check your answer. Please let me know how you do.
>>IMAGE."
Sheriff
Such as GUI development, talking to database thru Java etc. I don't think many employers want to deliver a "DOS App". If you feel comfortable with delivering in a Client Server environment, work with databases, and things like that, you shouldn't have a problem. Java is just the middle layer between you and an objective that's been sent in front of you...
Ryan
Ryan Headley<br /><a href="" target="_blank" rel="nofollow"></a>
I'm not looking for encouragement, I'm trying to tell, if it's possible to do so, whether I'm pursuing a realistic objective.
I appreciate these responses. I hope someone will address the question of whether Part 2 of the problem in my original post is easy or difficult. You sound like you have some experience, Ryan. Can you solve that problem easily?
If I had just started java and programming, and been handed that question I would have have found it very difficult.
- Janna
Sheriff
"JavaRanch, where the deer and the Certified play" - David O'Meara
First, to answer your question, I am a greenhorn in my second month of my first Java class, and I found the 2nd part of the problem to be as easy as the first. I'm not "smart", I just understood the jargon.
Second, most people are of average "smartness", and you appear to be at least that or more. Not everyone has logical aptitude, and the fact that you enjoyed the Cattle Drive course and found it easy testifies to your aptitude. Anyone who has that and enough determination and perserverence can master Java on average "smartness."
I'm studying Jave because I now work in an environment where things have been. I want to work in one where things are going. Sounds like you do too -- good luck!
class Baby {
Baby(int i) {
System.out.println("I am baby number " + i);
}
}
public class mybaby {
public static void main(String[] s) {
new Baby_11<<
"Programming today is a race between software engineers striving to build bigger and better idiot-proof programs, and the Universe trying to produce bigger and better idiots. So far, the Universe is winning."
The main doubt I have is about getting hired. I've read and heard stories (including the JavaRanch forums) about people learning java on their own and passing the Sun Cert. Java Programmer exam and STILL not being able to get a job without experience. I'd like to hear if anyone knows about the likelihood of getting hired without professional programming experience...and how you get around the chicken-and-the-egg issue here.
Ranch Hand
Originally posted by Jamie Cole:
I'd like to earn a living by programming in Java, but I can't tell whether I've got what it takes. I enjoyed and had little trouble with the course here at JavaRanch. I've been studying from other sources on my own, and found some of it easy, some perplexing. If I have the aptitude to succeed as a professional programmer, should I be finding introductory courses quite easy?
Here's an example. Below is one of the exercises in Richard Baldwin's introductory online Java course. Part 1 is easy, but I found Part 2 very difficult. [snip] How hard should this be for someone who will do well at programming?
Jamie, I think it is tough to learn any language when the examples are "terse". I wouldn't let part 2 throw you -- it is a somewhat unusual use of Java syntax.
Java "grows on you" with time -- it is a HUGE language, and you needn't be a master of it all in order to consider yourself competent.
As another example, you might want to take a look at the sample application that I developed as companion code to my book (it is available as a free download from the website) to see whether that code makes sense to you.
Regards,
Jacquie
------------------
author of:
Beginning Java Objects
I posted another problem that perplexed me in the Intermediate forum, because it seemed a little much for this one. I was hoping someone with a good mix of verbal and Java skills would take a look. I hope you can spare a couple of minutes for it. Here's the post:
I understand your predicament which basically seems to arise out of the friction between your urge to learn Java and the seemingly
unsurmountable task ahead. I was in a similar situation a few weeks back but my resolve to get up there has got me past the crossroad. I still have a long long way to go and with every passing day the confidence seems to grow and as Jacquie has rightly said 'Java grows on you'. So, I would advise you to adopt a positive approach and just keep going, do not get bogged down by the enormity of the task but derive inspiration from each step you climb up. GOOD LUCK.
regards,
Rajendra.
- Instantiate an object
- Call a parametized constructor
- As a parameter to a function (I prefer to use the Java term "method"
I worked these three backwards. First I created a method that took in a string parameter -- that took care of part 3. Then I created a Tester class that had one parametized constructor, requiring a string parameter. Lastly I created the main method, taking in a string command-line argument, and in one line, mashing all the requirements together with a call to my test method, passing as a parameter a 'new Tester(args[0])', which accomplished parts 2 and 1 simultaneously.
Now, more to the point, I found Baldwin's answer, like his question, to be a bit confusing. I think both could have been stated a bit more simply. As students, we shouldn't assume that because we don't clearly understand the question, the problem lies with us. I think it is easy to obfuscate the obvious to the point that anyone would have difficulty. In the real programming world, you could ask questions until you understood the requirement. And you're plenty "smart enough" to come up with the answer.
This is the answer I came up with
and in another source file
It's quite similar to the solution and it only took about 15 minutes to write the code. BUT it took me twice as long to decode the question. And I've been working as a C programmer for a couple of years and learning Java for about 6 months - I'd consider myself fairly OK at understanding technical specifications and I found these instructions confusing. I do know it took about 6 months to understand the terminology when I started and it was hard to find books that didn't assume that you knew some of the basic terminology. If you're doing other assignments OK, I wouldn't be too concerned - the aptitude tests are quite good, although the ones I've seen have been a bit procedural orientated - I haven't seen the brainbench one.
Hope this helps,
Kathy
Here's my solution. It took about 10 minutes with the usual family interruptions.
It produces the correct output so now I'll have a look at the site you referred to ..... Hmm. Well, my solution looks fine. It meets the requirements and is actually simpler than his, while covering the essential points. He might complain about me making getABaldwin static to simplify things, but there was no stipulation in the question covering that, so I took a shortcut.
A couple of points. One, there is no single correct answer to this type of question, though there are obviously many incorrect answers. Even people with a "perfect" knowledge of Java can give incorrect answers as you have noticed.
Second, this question sounds more difficult than it actually is. The trick is to break it down into smaller parts, as has been noticed. Breaking complex questions down into smaller problems is part of the skill of a programmer (or any other problem-solver).
Third, I had to read the question twice before it fell into place. Once I understood the question some examples sprang to mind pretty quickly. eg. myFrame.setLayout( new GridLayout(2,0)) is the same type of thing.
I searched in google for "computer programming aptitude test" and found many sites, most commercial, but some free and others with sample questions. eg. I haven't done the test. But the real test is whether you can write programs.
Obviously there is much more to being a programmer than just cutting code ( good design, following standards, following requirements carefully, testing, etc ) but solving problems algorithmically is at the heart of it.
Hope this helps.
I have to agree with Cindy when she said, "they are testing your reading skill more than your programming skill." Almost all examples of using the java.io.* classes are littered with the part 2 of your question.
For example,
File myFile = new File("output.txt");
FileOutputStream fos = new FileOutputStream(myFile);
Part 2 just combines the two statements into one:
FileOutputStream fos =
new FileOutputStream(new File("output.txt"));
If you didn't get this the first time around, don't worry about it. I woudn't have understood the question the first time around either. I've just been reading a lot of JAVA books and gotten use to the jargon. If you're serious about becoming a JAVA programmer, I would recommend:
1. Read a lot of code and try them out. It's really important to type out the code and try things out if they don't make sense to you. Given a choice between downloading the source file and typing the example from the book, I would type the code out because I learn from the mistakes I make this way. Downloading the working source file doesn't teach you anything other than the fact that you can use a mouse.
2. Reading bad code is just as helpful as reading good code. I learn what not to do reading bad code.
3. Ask questions! If it doesn't make sense, ask someone. If they can't answer your question or if the answer doesn't make sense, then say so. Don't accept an answer until it makes sense to you.
Good luck!
-Peter
And to anyone wondering how it is to program java, I would like to say that having programming a variety of languages on and off for about fifteen years, I find java about as easy or difficult as any language, depending on what you want to use it for...
I currently work with web development, where I have written a few applets, a few Windows-components (in VB and C++), but most of my 'programming' these days is scripting.
I found the question mentioned quite easy, but having my experience it would be strange otherwise. Not only java experience helps me here, the question and solution would look more or less the same if it was about c++, as would many java problems due to the similarities in java and c++ when it comes to syntax and OO approach.
I generally tend to find programming quite difficult, that's why I have not yet grown tired of it..
Regards, Marius
Ranch Hand
I'm not 14 and I do not understand the java language perfectly (I hope I never do). People tell me I'm intelligent but, for me, I don't think that it has anything to do with book learnin' or smarts. As Edison said "genius is 99% perspiration and one percent inspiration". Which is really true. I used to play classical guitar professionally and people would say stuff like "Wow, I could never do that. You're so gifted." or whatever. Well, the only gift I had was the six to eight hours a day I practiced for 10+ years. Same thing with programming. Sure I got good marks but that's just a by-product of staying up untill 4am because you just have to make it 'perfect'. However, that one percent inspiration is very important as well, and many 'smart' folks don't have a clue where to find that spark. I get more ideas for 'clever' solutions cooking omlettes that I do reading a white paper. The 99% will come if you love what your doing - that makes it easy. Programming isn't about knowing a language - its about solving puzzles, exploring unique trains of thought and hammering away until you get it right. The programmers that I've known during my degree and here at work have very diverse backgrounds but the common traits seem to be a love of solving problems, a desire to do well at whatever they are confronted with and a confidence that speaks "If anyone can do this, I can do this". I hope this helps you figure out you aptitude for programming. Personally, I'd say that if you've ever felt that glow after seeing you first "Hello world!" appear on the screen, then you're fully qualified to explore programming.
Sean
[This message has been edited by Jamie Cole (edited January 03, 2001).]
------------------_30<<
I consider myself to be in somewhat the same boat as you. I have a fairly extensive schooling background in c++, but no real experience. I've only been looking at Java for about a month and it seems, to me anyway, quite a bit easier than c++.
I was able to answer the question in about 10 minutes. I'm not sure if my solution is formatted correctly, but it does work. The key to me was in how the question was read. I took it to mean that Mr. Baldwin was looking for a demonstration of an overloaded constructor, and I went from there.
class BaldwinTest
{
BaldwinTest()
{
System.out.println("Starting Program");
runParamBaldwin(new BaldwinTest(100));
System.out.println("Terminating, Baldwin");
}
BaldwinTest(int i)
{
System.out.println("Object contains " + i);
}
static void runParamBaldwin(BaldwinTest b)
{
}
public static void main(String[] args)
{
BaldwinTest b = new BaldwinTest();
}
}
My advice would be echo quite a few of the other responses here. The key lies in purchasing a GOOD book (read the reviews both here and at amazon before making a purchase), working through all of the examples, and don't hesitate to ask questions. Take a break when you're stymied and sooner or later you'll break through the "wall".
Good luck,
Pat B.
Originally posted by Jamie Cole:
Thanks, Greg. Yes, it does help. Your solution is simpler, and as far as I'm concerned, simpler is better. Thanks also for pointing out the MyFrame parallel. I've used that type of construction before, but it hadn't occurred to me. To put your response in context, how much programming experience do you have?
Jamie
About 13 years programming, mostly on Oracle/Unix - sql, pl/sql, ksh, awk, some C, various others. I've been writing Java in my spare time for the past few years on and off.
You've done more than enough for me already, but if you're interested, please take a look at my Towers of Hanoi topic in the Intermediate forum. My question there seems to be either too difficult or too time-consuming to answer -- or maybe too obvious. I hope not the latter.
[This message has been edited by Jamie Cole (edited January 03, 2001).]
having patience.
<pre>
public class Baldwin {
public static void main(String args[]){
// 1. Instantiating an pbject by calling the default constructor
String s = new String();
String t;
System.out.println("Starting program");
// 2. Instantiating an object by calling a parametrized constructor
// String(java.lang.String)
// As parameter to a function call
// System.out.println(java.lang.String)
System.out.println(t = new String("Object contains 100"));
System.out.println("Terminating,Baldwin");
}
}
</pre>
you'll be a professional Java programer when you really want it , but like everithing in life , it takes some time
| https://coderanch.com/t/387562/java/java/smart-Java-programmer | CC-MAIN-2016-40 | en | refinedweb |
/* * Copyright (c)pbrk.c 8.1 (Berkeley) 6/4/93"; #endif /* LIBC_SCCS and not lint */ #include <sys/cdefs.h> __FBSDID("$FreeBSD: src/lib/libc/string/strpbrk.c,v 1.4 2002/03/21 18:44:54 obrien Exp $"); #include <string.h> /* * Find the first occurrence in s1 of a character in s2 (excluding NUL). */ char * strpbrk(s1, s2) const char *s1, *s2; { const char *scanp; int c, sc; while ((c = *s1++) != 0) { for (scanp = s2; (sc = *scanp++) != 0;) if (sc == c) return ((char *)(s1 - 1)); } return (NULL); } | http://opensource.apple.com//source/Libc/Libc-498/string/strpbrk-fbsd.c | CC-MAIN-2016-40 | en | refinedweb |
/* " /* Data type for the expressions representing sizes of data types. It is the first integer type laid out. */ tree sizetype_tab[(int) TYPE_KIND_LAST]; /* If nonzero, this is an upper limit on alignment of structure fields. The value is measured in bits. */ unsigned int maximum_field_alignment = TARGET_DEFAULT_PACK_STRUCT * BITS_PER_UNIT; /* ... and its original value in bytes, specified via -fpack-struct=<value>. */ unsigned int initial_max_fld_align = TARGET_DEFAULT_PACK_STRUCT; /* If nonzero, the alignment of a bitstring or (power-)set value, in bits. May be overridden by front-ends. */ unsigned int set_alignment = 0; /* Nonzero if all REFERENCE_TYPEs are internal and hence should be allocated in Pmode, not ptr_mode. Set only by internal_reference_types called only by a front end. */ static int reference_types_internal = 0; static void finalize_record_size ; /* Show that REFERENCE_TYPES are internal and should be Pmode. Called only by front end. */ /* APPLE LOCAL begin Macintosh alignment 2002-5-24 --ff */ /* Keep track of whether we are laying out the first declared member of a C++ class. We need this flag to handle the case of classes with v-tables where the test to see if the offset in the record is zero is not sufficient to determine if we are dealing with the first declared member. */ int darwin_align_is_first_member_of_class = 0; /* APPLE LOCAL end Macintosh alignment 2002-5-24 --ff */ void internal_reference_types ; /* If the language-processor is to take responsibility for variable-sized items (e.g., languages which have elaboration procedures like Ada), just return SIZE unchanged. Likewise for self-referential sizes and constant sizes. */ if (TREE_CONSTANT (size) || lang_hooks.decls.global_bindings_p () < 0 || CONTAINS_PLACEHOLDER_P (size)) return size; size = save_expr (size); /* If an array with a variable number of elements is declared, and the elements require destruction, we will emit a cleanup for the array. That cleanup is run both on normal exit from the block and in the exception-handler for the block. Normally, when code is used in both ordinary code and in an exception handler it is `unsaved', i.e., all SAVE_EXPRs are recalculated. However, we do not wish to do that here; the array-size is the same in both places. */ (unsigned int size, enum mode_class class, int limit) { enum machine_mode mode; if (limit && size > MAX_FIXED_MODE_SIZE) return BLKmode; /* Get the first mode which has this size, in the specified class. */ for (mode = GET_CLASS_NARROWEST_MODE (class); mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode)) if (GET_MODE_PRECISION (mode) == size) return mode; return BLKmode; } /* Similar, except passed a tree node. */ enum machine_mode mode_for_size_tree (tree size, enum mode_class class, int limit) { if (TREE_CODE (size) != INTEGER_CST || TREE_OVERFLOW (size) /* What we really want to say here is that the size can fit in a host integer, but we know there's no way we'd find a mode for this many bits, so there's no point in doing the precise test. */ || compare_tree_int (size, 1000) > 0) return BLKmode; else return mode_for_size (tree_mode (enum machine_mode mode) { switch (GET_MODE_CLASS (mode)) { case MODE_INT: case MODE_PARTIAL_INT: break; case MODE_COMPLEX_INT: case MODE_COMPLEX_FLOAT: case MODE_FLOAT: case MODE_VECTOR_INT: case MODE_VECTOR_FLOAT: mode = mode_for_size (GET_MODE_BITSIZE (mode), MODE_INT, 0); break; case MODE_RANDOM: if (mode == BLKmode) break; /* ... fall through ... */ case MODE_CC: default:); } } /* Set the size, mode and alignment of a ..._DECL node. TYPE_DECL does need this for C++. Note that LABEL_DECL and CONST_DECL nodes do not need this, and FUNCTION_DECL nodes have them set up in a special (and simple) way. Don't call layout_decl for them. KNOWN_ALIGN is the amount of alignment we can assume this decl has with no special effort. It is relevant only for FIELD_DECLs and depends on the previous fields. All that matters about KNOWN_ALIGN is which powers of 2 divide it. If KNOWN_ALIGN is 0, it means, "as much alignment as you like": the record will be aligned to suit. */ void layout_decl ); if (type == error_mark_node) type = void_type_node; /* Usually the size and mode come from the data type without change, however, the front-end may set the explicit width of the field, so its size may not be the same as the size of its type. This happens with bitfields, of course (an `int' bitfield may be only 2 bits, say), but it also happens with other fields. For example, the C++ front-end creates zero-sized fields corresponding to empty base classes, and depends on layout_type setting DECL_FIELD_BITPOS correctly for the field. Set the size in bytes from the size in bits. If we have already set the mode, don't set it again since we can be called twice for FIELD_DECLs. */); } /* Evaluate nonconstant size only once, either now or as soon as safe. */ if (DECL_SIZE (decl) != 0 && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST) DECL_SIZE (decl) = variable_size (DECL_SIZE (decl)); if (DECL_SIZE_UNIT (decl) != 0 && TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST) DECL_SIZE_UNIT (decl) = variable_size (DECL_SIZE_UNIT (decl)); /* If requested, warn about definitions of large data objects. */ if (warn_larger_than && (code == VAR_DECL || code == PARM_DECL) && ! DECL_EXTERNAL (decl)) { tree size = DECL_SIZE_UNIT (decl); if (size != 0 && TREE_CODE (size) == INTEGER_CST && compare_tree_int (size, larger_than_size) > 0) {) (record_layout_info)) { lang_adjust_rli = f; } /* Begin laying out type T, which may be a RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE. Return a pointer to a struct record_layout_info which is to be passed to all other layout functions for this record. It is the responsibility of the caller to call `free' for the storage returned. Note that garbage collection is not permitted until we finish laying out the record. */ record_layout_info start_record_layout (tree t) { record_layout_info rli = xmalloc (sizeof (struct record_layout_info_s)); rli->t = t; /* If the type has a minimum specified alignment (via an attribute declaration, for example) use it -- otherwise, start with a one-byte alignment. */ rli->record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (t)); rli->unpacked_align = rli->record_align; rli->offset_align = MAX (rli->record_align, BIGGEST_ALIGNMENT); #ifdef STRUCTURE_SIZE_BOUNDARY /* Packed structures don't need to have minimum size. */ if (! TYPE_PACKED (t)) rli->record_align = MAX (rli->record_align, (unsigned) STRUCTURE_SIZE_BOUNDARY); #endif rli->offset = size_zero_node; rli->bitpos = bitsize_zero_node; rli->prev_field = 0; rli->pending_statics = 0; rli->packed_maybe_necessary = 0; return rli; } /* These four routines perform computations that convert between the offset/bitpos forms and byte and bit offsets. */ tree bit_from_pos _convert (sizetype, size_binop (FLOOR_DIV_EXPR, pos, bitsize_int (off_align))), size_int (off_align / BITS_PER_UNIT)); *pbitpos = size_binop (FLOOR_MOD_EXPR, pos, bitsize_int (off_align)); } /* Given a pointer to bit and byte offsets and an offset alignment, normalize the offsets so they are within the alignment. */ void normalize_offset (tree *poffset, tree *pbitpos, unsigned int off_align) { /* If the bit position is now larger than it should be, adjust it downwards. */ if (compare_tree_int (*pbitpos, off_align) >= 0) { tree extra_aligns = size_binop (FLOOR_DIV_EXPR, *pbitpos, bitsize_int (off_align)); *poffset = size_binop (PLUS_EXPR, *poffset, size_binop (MULT_EXPR, fold_convert (sizetype, extra_aligns), size_int (off_align / BITS_PER_UNIT))); *pbitpos = size_binop (FLOOR_MOD_EXPR, *pbitpos, bitsize_int (off_align)); } } /* Print debugging information about the information in RLI. */ void debug_rli (record_layout_info rli) { print_node_brief (stderr, "type", rli->t, 0); print_node_brief (stderr, "\noffset", rli->offset, 0); print_node_brief (stderr, " bitpos", rli->bitpos, 0); fprintf (stderr, "\naligns: rec = %u, unpack = %u, off = %u\n", rli->record_align, rli->unpacked_align, rli->offset_align); if (rli->packed_maybe_necessary) fprintf (stderr, "packed may be necessary\n"); if (rli->pending_statics) { fprintf (stderr, "pending statics:\n"); debug_tree (rli->pending_statics); } } /* Given an RLI with a possibly-incremented BITPOS, adjust OFFSET and BITPOS if necessary to keep BITPOS below OFFSET_ALIGN. */ void normalize_rli (record_layout_info rli) { return bit_from_pos (rli->offset, rli->bitpos); } /* FIELD is about to be added to RLI->T. The alignment (in bits) of the next available location is given by KNOWN_ALIGN. Update the variable alignment fields in RLI, and return the alignment to give the FIELD. */. */ if (is_bitfield && targetm.ms_bitfield_layout_p (rli->t)) { /* Here, the alignment of the underlying type of a bitfield can affect the alignment of a record; even a zero-sized field can do this. The alignment should be to the alignment of the type, except that for zero-size bitfields this only applies if there was an immediately prior, nonzero-size bitfield. (That's the way it is, experimentally.) */ if (! integer_zerop (DECL_SIZE (field)) ? ! DECL_PACKED (field) : (rli->prev_field && DECL_BIT_FIELD_TYPE (rli->prev_field) && ! integer_zerop (DECL_SIZE (rli->prev_field)))) { unsigned int type_align = TYPE_ALIGN (type); type_align = MAX (type_align, desired_align); if (maximum_field_alignment != 0) type_align = MIN (type_align, maximum_field_alignment); rli->record_align = MAX (rli->record_align, type_align); rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type)); } } ()) { unsigned int type_align = TYPE_ALIGN (type); */ /*_field (record_layout_info rli, tree field) { update_alignment_for_field (rli, field, /*known_align=*/0); DECL_FIELD_OFFSET (field) = size_zero_node; DECL_FIELD_BIT_OFFSET (field) = bitsize_zero_node; SET_DECL_OFFSET_ALIGN (field, BIGGEST_ALIGNMENT); /* We assume the union's size will be a multiple of a byte so we don't bother with BITPOS. */ if (TREE_CODE (rli->t) == UNION_TYPE) rli->offset = size_binop (MAX_EXPR, rli->offset, DECL_SIZE_UNIT (field)); else if (TREE_CODE (rli->t) == QUAL_UNION_TYPE) rli->offset = fold (build /* RLI contains information about the layout of a RECORD_TYPE. FIELD is a FIELD_DECL to be added after those fields already present in T. (FIELD is not actually added to the TYPE_FIELDS list here; callers that desire that behavior must manually perform that step.) */ void place_field (record_layout_info rli, tree field) { /* The alignment required for FIELD. */ unsigned int desired_align; /* The alignment FIELD would have if we just dropped it into the record as it presently stands. */ unsigned int known_align; unsigned int actual_align; /* The type of this field. */ tree type = TREE_TYPE (field); if (TREE_CODE (field) == ERROR_MARK || TREE_CODE (type) == ERROR_MARK) return; /* If FIELD is static, then treat it like a separate variable, not really like a structure field. If it is a FUNCTION_DECL, it's a method. In both cases, all we do is lay out the decl, and we do it *after* the record is laid out. */ if (TREE_CODE (field) == VAR_DECL) { rli->pending_statics = tree_cons (NULL_TREE, field, rli->pending_statics); return; } /* Enumerators and enum types which are local to this class need not be laid out. Likewise for initialized constant fields. */ else if (TREE_CODE (field) != FIELD_DECL) return; /* Unions are laid out very differently than records, so split that code off to another function. */ else if (TREE_CODE (rli->t) != RECORD_TYPE) { place_union_field (rli, field); return; } /* Work out the known alignment so far. Note that A & (-A) is the value of the least-significant bit in A that is one. */ if (! integer_zerop (rli->bitpos)) known_align = (tree_low_cst (rli->bitpos, 1) & - tree_low_cst (rli->bitpos, 1)); else if (integer_zerop (rli->offset)) known_align = BIGGEST_ALIGNMENT; else if (host_integerp (rli->offset, 1)) known_align = (BITS_PER_UNIT * (tree_low_cst (rli->offset, 1) & - tree_low_cst (rli->offset, 1))); else known_align = rli->offset_align; desired_align = update_alignment_for_field (rli, field, known_align); if (warn_packed && DECL_PACKED (field)) { if (known_align >= TYPE_ALIGN (type)) { if (TYPE_ALIGN (type) > desired_align) { if (STRICT_ALIGNMENT) warning ("%Jpacked attribute causes inefficient alignment " "for %qD", field, field); else warning ("%Jpacked attribute is unnecessary for %qD", field, field); } } ("%Jpadding struct to align %qD", field, field); /* If the alignment is still within offset_align, just align the bit position. */ if (desired_align < rli->offset_align) rli->bitpos = round_up (rli->bitpos, desired_align); else { /* First adjust OFFSET by the partial bits, then align. */ rli->offset = size_binop (PLUS_EXPR, rli->offset, fold_convert (sizetype, size_binop (CEIL_DIV_EXPR, rli->bitpos, bitsize_unit_node))); rli->bitpos = bitsize_zero_node; rli->offset = round_up (rli->offset, desired_align / BITS_PER_UNIT); } if (! TREE_CONSTANT (rli->offset)) rli->offset_align = desired_align; } /* Handle compatibility with PCC. Note that if the record has any variable-sized fields, we need not worry about compatibility. */ #ifdef PCC_BITFIELD_TYPE_MATTERS if (PCC_BITFIELD_TYPE_MATTERS && ! targetm.ms_bitfield_layout_p (rli->t) && TREE_CODE (field) == FIELD_DECL && type != error_mark_node && DECL_BIT_FIELD (field) && ! DECL_PACKED (field) && maximum_field_alignment == 0 /* APPLE LOCAL begin Macintosh alignment 2002-2-12 --ff */ #ifdef PEG_ALIGN_FOR_MAC68K && ! TARGET_ALIGN_MAC68K #endif /* APPLE LOCAL end Macintosh alignment 2002-2-12 --ff */ && ! /* A bit field may not span more units of alignment of its type than its type itself. Advance to next boundary if necessary. */ if (excess_unit_span (offset, bit_offset, field_size, type_align, type)) rli->bitpos = round_up (rli->bitpos, type_align); TYPE_USER_ALIGN (rli->t) |= TYPE_USER_ALIGN (type); } #endif #ifdef BITFIELD_NBYTES_LIMITED if (BITFIELD_NBYTES_LIMITED && ! targetm.ms_bitfield_layout_p (rli->t) && TREE_CODE (field) == FIELD_DECL && type != error_mark_node && DECL_BIT_FIELD_TYPE (field) && ! DECL_PACKED (field) && !); /* ??? This test is opposite the test in the containing if statement, so this code is unreachable currently. */ */ /* A bit field may not span the unit of alignment of its type. Advance to next boundary if necessary. */ if (excess_unit_span (offset, bit_offset, field_size, type_align, type)) rli->bitpos = round_up (rli->bitpos, type_align); TYPE_USER_ALIGN (rli->t) |= TYPE_USER_ALIGN (type); } #endif /* See the docs for TARGET_MS_BITFIELD_LAYOUT_P for details. A subtlety: When a bit field is inserted into a packed record, the whole size of the underlying type is used by one or more same-size adjacent bitfields. (That is, if its long:3, 32 bits is used in the record, and any additional adjacent long bitfields are packed into the same chunk of 32 bits. However, if the size changes, a new field of that size is allocated.) In an unpacked record, this is the same as using alignment, but not equivalent when packing. Note: for compatibility,. */) { /* If both are bitfields, nonzero, and the same size, this is the middle of a run. Zero declared size fields are special and handled as "end of run". (Note: it's nonzero declared size, but equal type sizes!) (Since we know that both the current and previous fields are bitfields by the time we check it, DECL_SIZE must be present for both.) */ if (DECL_BIT_FIELD_TYPE (field) && !integer_zerop (DECL_SIZE (field)) && !integer_zerop (DECL_SIZE ), 0); if (rli->remaining_in_alignment < bitsize) { /*), 0); } rli->remaining_in_alignment -= bitsize; } else { /* End of a run: if leaving a run of bitfields of the same type size, we have to "use up" the rest of the bits of the type size. Compute the new position as the sum of the size for the prior type and where we first started working on that type. Note: since the beginning of the field was aligned then of course the end will be too. No round needed. */; /* Cause a new bitfield to be captured, either this time (if currently a bitfield) or next time we see one. */ if (!DECL_BIT_FIELD_TYPE(field) || integer_zerop (DECL_SIZE (field))) rli->prev_field = NULL; } normalize_rli (rli); } /* If we're starting a new run of same size type bitfields (or a run of non-bitfields), set up the "first of the run" fields. That is, if the current field is not a bitfield, or if there was a prior bitfield the type sizes differ, or if there wasn't a prior bitfield the size of the current field is nonzero. Note: we must be sure to test ONLY the type size if there was a prior bitfield and ONLY for the current field being zero if there wasn't. */ if (!DECL_BIT_FIELD_TYPE (field) || ( prev_saved != NULL ? !simple_cst_equal (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (prev_saved))) : !integer_zerop (DECL_SIZE (field)) )) { /*)), 0) - tree_low_cst (DECL_SIZE (field), 0); /*); /* APPLE LOCAL begin reverse_bitfields */ if (targetm.reverse_bitfields_p (rli->t) && DECL_BIT_FIELD_TYPE (field)) { /* If we've gone into the next word, move "offset" forward and adjust "bitpos" to compensate. */ while ( !INT_CST_LT_UNSIGNED (rli->bitpos, TYPE_SIZE (TREE_TYPE (field)))) { rli->offset = size_binop (PLUS_EXPR, rli->offset, TYPE_SIZE_UNIT (TREE_TYPE (field))); rli->bitpos = size_binop (MINUS_EXPR, rli->bitpos, TYPE_SIZE (TREE_TYPE (field))); } DECL_FIELD_BIT_OFFSET (field) = size_binop (MINUS_EXPR, size_binop (MINUS_EXPR, TYPE_SIZE (TREE_TYPE (field)), DECL_SIZE (field)), rli->bitpos); } else DECL_FIELD_BIT_OFFSET (field) = rli->bitpos; DECL_FIELD_OFFSET (field) = rli->offset; /* APPLE LOCAL end reverse bitfields */ SET_DECL_OFFSET_ALIGN (field, rli->offset_align); /* = BIGGEST_ALIGNMENT; else if (host_integerp (DECL_FIELD_OFFSET (field), 1)) actual_align = (BITS_PER_UNIT * (tree_low_cst (DECL_FIELD_OFFSET (field), 1) & - tree_low_cst (DECL_FIELD_OFFSET (field), 1))); else actual_align = DECL_OFFSET_ALIGN (field); if (known_align != actual_align) layout_decl (field, actual_align); /* Only the MS bitfields use this. */ if (rli->prev_field == NULL && DECL_BIT_FIELD_TYPE(field)) rli->prev_field = field; /* Now add size of this field to the size of the record. If the size is not constant, treat the field as being a multiple of bytes and just adjust the offset, resetting the bit position. Otherwise, apportion the size amongst the bit position and offset. First handle the case of an unspecified size, which can happen when we have an invalid nested struct definition, such as struct j { struct j { int i; } }. The error message is printed in finish_struct. */ if (DECL_SIZE (field) == 0) /* Do nothing. */; else if (TREE_CODE (DECL_SIZE_UNIT (field)) != INTEGER_CST || TREE_CONSTANT_OVERFLOW (DECL_SIZE_UNIT (field))) { rli->offset = size_binop (PLUS_EXPR, rli->offset, fold_convert (sizetype, size_binop (CEIL_DIV_EXPR, rli->bitpos, bitsize_unit_node))); rli->offset = size_binop (PLUS_EXPR, rli->offset, DECL_SIZE_UNIT (field)); rli->bitpos = bitsize_zero_node; rli->offset_align = MIN (rli->offset_align, desired_align); } (record_layout_info rli) { tree unpadded_size, unpadded_size_unit; /* Now we want just byte and bit offsets, so set the offset alignment to be a byte and then normalize. */ rli->offset_align = BITS_PER_UNIT; normalize_rli (rli); /* Determine the desired alignment. */ #ifdef ROUND_TYPE_ALIGN TYPE_ALIGN (rli->t) = ROUND_TYPE_ALIGN (rli->t, TYPE_ALIGN (rli->t), rli->record_align); #else TYPE_ALIGN (rli->t) = MAX (TYPE_ALIGN (rli->t), rli->record_align); #endif /* Compute the size so far. Be sure to allow for extra bits in the size in bytes. We have guaranteed above that it will be no more than a single byte. */ unpadded_size = rli_size_so_far (rli); unpadded_size_unit = rli_size_unit_so_far (rli); if (! integer_zerop (rli->bitpos)) unpadded_size_unit = size_binop (PLUS_EXPR, unpadded_size_unit, size_one_node); /* Round the size up to be a multiple of the required alignment. */ TYPE_SIZE (rli->t) = round_up (unpadded_size, TYPE_ALIGN (rli->t)); TYPE_SIZE_UNIT (rli->t) = round_up (unpadded_size_unit, TYPE_ALIGN_UNIT (rli->t)); if (warn_padded && TREE_CONSTANT (unpadded_size) && simple_cst_equal (unpadded_size, TYPE_SIZE (rli->t)) == 0) warning ("padding struct size to alignment boundary"); if (warn_packed && TREE_CODE (rli->t) == RECORD_TYPE && TYPE_PACKED (rli->t) && ! rli->packed_maybe_necessary && TREE_CONSTANT (unpadded_size)) { tree unpacked_size; #ifdef ROUND_TYPE_ALIGN rli->unpacked_align = ROUND_TYPE_ALIGN (rli->t, TYPE_ALIGN (rli->t), rli->unpacked_align); #else rli->unpacked_align = MAX (TYPE_ALIGN (rli->t), rli->unpacked_align); #endif unpacked_size = round_up (TYPE_SIZE (rli->t), rli->unpacked_align); if (simple_cst_equal (unpacked_size, TYPE_SIZE (rli->t))) { TYPE_PACKED (rli->t) = 0; if (TYPE_NAME (rli->t)) { const char *name; if (TREE_CODE (TYPE_NAME (rli->t)) == IDENTIFIER_NODE) name = IDENTIFIER_POINTER (TYPE_NAME (rli->t)); else name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (rli->t))); if (STRICT_ALIGNMENT) warning ("packed attribute causes inefficient " "alignment for %qs", name); else warning ("packed attribute is unnecessary for %qs", name); } else { if (STRICT_ALIGNMENT) warning ("packed attribute causes inefficient alignment"); else warning ("packed attribute is unnecessary"); } } } } /* Compute the TYPE_MODE for the TYPE (which is a RECORD_TYPE). */ void compute_record_mode (tree type) { tree field; enum machine_mode mode = VOIDmode; /* Most RECORD_TYPEs have BLKmode, so we start off assuming that. However, if possible, we use a mode that fits in a register instead, in order to allow for better optimization down the line. */ TYPE_MODE (type) = BLKmode; if (! host_integerp (TYPE_SIZE (type), 1)) return; /* A record which has any BLKmode members must itself be BLKmode; it can't go in a register. Unless the member is BLKmode only because it isn't aligned. */ for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) {)) return; /* MEMBER_TYPE_FORCES_BLK /* With some targets, eg. c4x, it is sub-optimal to access an aligned BLKmode structure as a scalar. */ if (MEMBER_TYPE_FORCES_BLK (field, mode)) return; #endif /* MEMBER_TYPE_FORCES_BLK */ } /*; #if defined RS6000_VARARGS_AREA /* Make 8-byte structs BLKmode instead of DImode, which fixes both struct-return methods and attempts to use floats in kernel code. This should probably become a generic macro similar to MEMBER_TYPE_FORCES_BLK above. */ else if (mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1) == DImode) ; #endif else TYPE_MODE (type) = mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1); /* APPLE LOCAL end 8-byte-struct hack */ /* If structure's known alignment is less than what the scalar mode would need, and it matters, then stick with BLKmode. */ if (TYPE_MODE (type) != BLKmode && STRICT_ALIGNMENT && ! (TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT || TYPE_ALIGN (type) >= GET_MODE_ALIGNMENT (TYPE_MODE (type)))) { /* If this is the only reason this type is BLKmode, then don't force containing types to be BLKmode. */ TYPE_NO_FORCE_BLK (type) = 1; TYPE_MODE (type) = BLKmode; } } /* Compute TYPE_SIZE and TYPE_ALIGN for TYPE, once it has been laid out. */ static void finalize_type_size (tree type) { /* Normally, use the alignment corresponding to the mode chosen. However, where strict alignment is not required, avoid over-aligning structures, since most compilers do not do this alignment. */ if (TYPE_MODE (type) != BLKmode && TYPE_MODE (type) != VOIDmode && (STRICT_ALIGNMENT || (TREE_CODE (type) != RECORD_TYPE && TREE_CODE (type) != UNION_TYPE && TREE_CODE (type) != QUAL_UNION_TYPE && TREE_CODE (type) != ARRAY_TYPE))) { TYPE_ALIGN (type) = GET_MODE_ALIGNMENT (TYPE_MODE (type)); TYPE_USER_ALIGN (type) = 0; } /* Do machine-dependent extra alignment. */ #ifdef ROUND_TYPE_ALIGN TYPE_ALIGN (type) = ROUND_TYPE_ALIGN (type, TYPE_ALIGN (type), BITS_PER_UNIT); #endif /* If we failed to find a simple way to calculate the unit size of the type, find it by division. */ if (TYPE_SIZE_UNIT (type) == 0 && TYPE_SIZE (type) != 0) /* TYPE_SIZE (type) is computed in bitsizetype. After the division, the result will fit in sizetype. We will get more efficient code using sizetype, so we force a conversion. */ TYPE_SIZE_UNIT (type) = fold_convert (sizetype, size_binop (FLOOR_DIV_EXPR, TYPE_SIZE (type), bitsize_unit_node)); if (TYPE_SIZE (type) != 0) { TYPE_SIZE (type) = round_up (TYPE_SIZE (type), TYPE_ALIGN (type)); TYPE_SIZE_UNIT (type) = round_up (TYPE_SIZE_UNIT (type), TYPE_ALIGN_UNIT (type)); } /* Evaluate nonconstant sizes only once, either now or as soon as safe. */ if (TYPE_SIZE (type) != 0 && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) TYPE_SIZE (type) = variable_size (TYPE_SIZE (type)); if (TYPE_SIZE_UNIT (type) != 0 && TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST) TYPE_SIZE_UNIT (type) = variable_size (TYPE_SIZE_UNIT (type)); /* Also layout any other variants of the type. */ if (TYPE_NEXT_VARIANT (type) || type != TYPE_MAIN_VARIANT (type)) { tree variant; /* Record layout info of this variant. */ tree size = TYPE_SIZE (type); tree size_unit = TYPE_SIZE_UNIT (type); unsigned int align = TYPE_ALIGN (type); unsigned int user_align = TYPE_USER_ALIGN (type); enum machine_mode mode = TYPE_MODE (type); /* Copy it into all variants. */ for (variant = TYPE_MAIN_VARIANT (type); variant != 0; variant = TYPE_NEXT_VARIANT (variant)) { TYPE_SIZE (variant) = size; TYPE_SIZE_UNIT (variant) = size_unit; TYPE_ALIGN (variant) = align; TYPE_USER_ALIGN (variant) = user_align; TYPE_MODE (variant) = mode; } } } /* Do all of the work required to layout the type indicated by RLI, once the fields have been laid out. This function will call `free' for RLI, unless FREE_P is false. Passing a value other than false for FREE_P is bad practice; this option only exists to support the G++ 3.2 ABI. */ void finish_record_layout (record_layout_info rli, int free_p) { /* Compute the final size. */ finalize_record_size (rli); /* Compute the TYPE_MODE for the record. */ compute_record_mode (rli->t); /* Perform any last tweaks to the TYPE_SIZE, etc. */ finalize_type_size (rli->t); /* Lay out any static members. This is done now because their type may use the record's type. */ while (rli->pending_statics) { layout_decl (TREE_VALUE (rli->pending_statics), 0); rli->pending_statics = TREE_CHAIN (rli->pending_statics); } /* Clean up. */ if (free_p) free (rli); } /*); } /* Calculate the mode, size, and alignment for TYPE. For an array type, calculate the element separation as well. Record TYPE on the chain of permanent or temporary types so that dbxout will find out about it. TYPE_SIZE of a type is nonzero if the type has been laid out already. layout_type does nothing on such a type. If the type is incomplete, its TYPE_SIZE remains zero. */ void layout_type (tree type) { gcc_assert (type); if (type == error_mark_node) return; /* Do nothing if type has been laid out before. */ if (TYPE_SIZE (type)) return; switch (TREE_CODE (type)) { case LANG_TYPE: /* This kind of type is the responsibility of the language-specific code. */ gcc_unreachable (); case BOOLEAN_TYPE: /* Used for Java, Pascal, and Chill. */ if (TYPE_PRECISION (type) == 0) TYPE_PRECISION (type) = 1; /* default to one byte/boolean. */ /* ... fall through ... */ case INTEGER_TYPE: case ENUMERAL_TYPE: case CHAR_TYPE: if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST && tree_int_cst_sgn (TYPE_MIN_VALUE (type)) >= 0) TYPE_UNSIGNED (type) = 1; TYPE_MODE (type) = smallest_mode_for_size (TYPE_PRECISION (type), MODE_INT); TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type))); TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type))); break; case REAL_TYPE: TYPE_MODE (type) = mode_for_size (TYPE_PRECISION (type), MODE_FLOAT, 0); TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type))); TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type))); break; case COMPLEX); break; } case VOID_TYPE: /* This is an incomplete type and so doesn't have a size. */ TYPE_ALIGN (type) = 1; TYPE_USER_ALIGN (type) = 0; TYPE_MODE (type) = VOIDmode; break; case OFFSET_TYPE: TYPE_SIZE (type) = bitsize_int (POINTER_SIZE); TYPE_SIZE_UNIT (type) = size_int (POINTER_SIZE / BITS_PER_UNIT); /* A pointer might be MODE_PARTIAL_INT, but ptrdiff_t must be integral. */ TYPE_MODE (type) = mode_for_size (POINTER_SIZE, MODE_INT, 0); break; case FUNCTION_TYPE: case METHOD_TYPE: /*_UNSIGNED (type) = 1; TYPE_PRECISION (type) = nbits; } break; case ARRAY_TYPE: { tree index = TYPE_DOMAIN (type); tree element = TREE_TYPE (type); build_pointer_type (element); /* We need to know both bounds in order to compute the size. */ if (index && TYPE_MAX_VALUE (index) && TYPE_MIN_VALUE (index) && TYPE_SIZE (element)) { tree ub = TYPE_MAX_VALUE (index); tree lb = TYPE_MIN_VALUE (index); tree length; tree element_size; /* The initial subtraction should happen in the original type so that (possible) negative values are handled appropriately. */ length = size_binop (PLUS_EXPR, size_one_node, fold_convert (sizetype, fold (build2 (MINUS_EXPR, TREE_TYPE (lb), ub, lb)))); /* Special handling for arrays of bits (for Chill). */ element_size = TYPE_SIZE (element); if (TYPE_PACKED (type) && INTEGRAL_TYPE_P (element) && (integer_zerop (TYPE_MAX_VALUE (element)) || integer_onep (TYPE_MAX_VALUE (element))) && host_integerp (TYPE_MIN_VALUE (element), 1)) { HOST_WIDE_INT maxvalue = tree_low_cst (TYPE_MAX_VALUE (element), 1); HOST_WIDE_INT minvalue = tree_low_cst (TYPE_MIN_VALUE (element), 1); if (maxvalue - minvalue == 1 && (maxvalue == 1 || maxvalue == 0)) element_size = integer_one_node; } /*_convert (bitsizetype, length)); /* If we know the size of the element, calculate the total size directly, rather than do some division thing below. This optimization helps Fortran assumed-size arrays (where the size of the array is determined at runtime) substantially. Note that we can't do this in the case where the size of the elements is one bit since TYPE_SIZE_UNIT cannot be set correctly in that case. */ if (TYPE_SIZE_UNIT (element) != 0 && ! integer_onep (element_size)) TYPE_SIZE_UNIT (type) = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (element), length); } /* Now round the alignment and size, using machine-dependent criteria if any. */ #ifdef ROUND_TYPE_ALIGN TYPE_ALIGN (type) = ROUND_TYPE_ALIGN (type, TYPE_ALIGN (element), BITS_PER_UNIT); #else TYPE_ALIGN (type) = MAX (TYPE_ALIGN (element), BITS_PER_UNIT); #endif TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (element); TYPE_MODE (type) = BLKmode; if (TYPE_SIZE (type) != 0 #ifdef MEMBER_TYPE_FORCES_BLK && ! MEMBER_TYPE_FORCES_BLK (type, VOIDmode) #endif /* BLKmode elements force BLKmode aggregate; else extract/store fields may lose. */ && (TYPE_MODE (TREE_TYPE (type)) != BLKmode || TYPE_NO_FORCE_BLK (TREE_TYPE (type)))) { /* One-element arrays get the component type's mode. */ if (simple_cst_equal (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (type)))) TYPE_MODE (type) = TYPE_MODE (TREE_TYPE (type)); else TYPE_MODE (type) = mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1); if (TYPE_MODE (type) != BLKmode && STRICT_ALIGNMENT && TYPE_ALIGN (type) < BIGGEST_ALIGNMENT && TYPE_ALIGN (type) < GET_MODE_ALIGNMENT (TYPE_MODE (type)) && TYPE_MODE (type) != BLKmode) { TYPE_NO_FORCE_BLK (type) = 1; TYPE_MODE (type) = BLKmode; } } break; } case RECORD_TYPE: case UNION_TYPE: case QUAL_UNION_TYPE: { tree field; record_layout_info rli; /* Initialize the layout information. */ rli = start_record_layout (type); /* If this is a QUAL_UNION_TYPE, we want to process the fields in the reverse order in building the COND_EXPR that denotes its size. We reverse them again later. */ if (TREE_CODE (type) == QUAL_UNION_TYPE) TYPE_FIELDS (type) = nreverse (TYPE_FIELDS (type)); /* Place all the fields. */ for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) place_field (rli, field); if (TREE_CODE (type) == QUAL_UNION_TYPE) TYPE_FIELDS (type) = nreverse (TYPE_FIELDS (type)); if (lang_adjust_rli) (*lang_adjust_rli) (rli); /* Finish laying out the record. */ finish_record_layout (rli, /*free_p=*/true); } break; case); /* If an alias set has been set for this aggregate when it was incomplete, force it into alias set 0. This is too conservative, but we cannot call record_component_aliases here because some frontends still change the aggregates after layout_type. */ if (AGGREGATE_TYPE_P (type) && TYPE_ALIAS_SET_KNOWN_P (type)) TYPE_ALIAS_SET (type) = 0; } /* Create and return a type for signed integers of PRECISION bits. */ tree make_signed type) { int oprecision = TYPE_PRECISION (type); /* The *bitsizetype types use a precision that avoids overflows when calculating signed sizes / offsets in bits. However, when cross-compiling from a 32 bit to a 64 bit host, we are limited to 64 bit precision. */ int precision = MIN (oprecision + BITS_PER_UNIT_LOG + 1, 2 * HOST_BITS_PER_WIDE the extreme values of TYPE based on its precision in bits, then lay it out. Used when make_signed_type won't do because the tree code is not INTEGER_TYPE. E.g. for Pascal, when the -fsigned-char option is given. */ void fixup_signed;; TYPE_UNSIGNED (type) = 1; set_min_and_max_values_for_integral_type (type, precision, /*is_unsigned=*/true); /* Lay out the type: set its alignment, size, etc. */ layout_type (type); } /* Find the best machine mode to use when referencing a bit field of length BITSIZE bits starting at BITPOS. The underlying object is known to be aligned to a boundary of ALIGN bits. If LARGEST_MODE is not VOIDmode, it means that we should not use a mode larger than LARGEST_MODE (usually SImode). If no mode meets all these conditions, we return VOIDmode. Otherwise, if VOLATILEP is true or SLOW_BYTE_ACCESS is false, we return the smallest mode meeting these conditions. Otherwise (VOLATILEP is false and SLOW_BYTE_ACCESS is true), we return the largest mode (but a mode no wider than UNITS_PER_WORD) that meets all the conditions. */ enum machine_mode get_best_mode (int bitsize, int bitpos, unsigned int align, enum machine_mode largest_mode, int volatilep) { enum machine_mode mode; unsigned int unit = 0; /* Find the narrowest integer mode that contains the bit field. */ for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode)) { unit = GET_MODE_BITSIZE (mode); if ((bitpos % unit) + bitsize <= unit) break; } if (mode == VOIDmode /* It is tempting to omit the following line if STRICT_ALIGNMENT is true. But that is incorrect, since if the bitfield uses part of 3 bytes and we use a 4-byte mode, we could get a spurious segv if the extra 4th byte is past the end of memory. (Though at least one Unix compiler ignores this problem: that on the Sequent 386 machine. */ || MIN (unit, BIGGEST_ALIGNMENT) > align || (largest_mode != VOIDmode && unit > GET_MODE_BITSIZE (largest_mode))) return VOIDmode; if (SLOW_BYTE_ACCESS && ! volatilep) { enum machine_mode wide_mode = VOIDmode, tmode; for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT); tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode)) { unit = GET_MODE_BITSIZE (tmode); if (bitpos / unit == (bitpos + bitsize - 1) / unit && unit <= BITS_PER_WORD && unit <= MIN (align, BIGGEST_ALIGNMENT) && (largest_mode == VOIDmode || unit <= GET_MODE_BITSIZE (largest_mode))) wide_mode = tmode; } if (wide_mode != VOIDmode) return wide_mode; } return mode; } /*" | http://opensource.apple.com//source/gcc/gcc-5026/gcc/stor-layout.c | CC-MAIN-2016-40 | en | refinedweb |
Byte To Binary Conversion - Online Code
Description
BinCat is a simple class for reading bytes and writing them back out in binary representation.
Source Code
import java.io.*; public class BinCat { BufferedInputStream brIn; PrintStream psOut; public static int BYTES_PER_LINE = 4; public BinCat() { this(System.in,System.out); }... (login or register to view full code)
To view full code, you must Login or Register, its FREE.
Hey, registering yourself just takes less than a minute and opens up a whole new GetGyan experience. | http://www.getgyan.com/show/1609/Byte_to_Binary_Conversion | CC-MAIN-2016-40 | en | refinedweb |
Very simple .class file that works only in Windows
Dear all, I wrote an MXJ really simple class that just creates a new folder on the hardisk.
I wrote and compiled it on Windows XP, but it does’nt work on Mac OSX.
Here there is the java file:
and here the .class:
This is the simple code:
import com.cycling74.max.*;
import java.io.File;
public class BmakeFolder extends MaxObject {
String path, name = "folder";
public BmakeFolder (Atom[] args)
{
createInfoOutlet(false);
declareInlets(new int[]{DataTypes.ALL});
declareOutlets(new int[]{DataTypes.ALL});
}
public void anything(String msg, Atom[] args)
{
File f = new File (msg);
f.mkdir();
}
}
Thank you very much.
Bruno
————————————————-
– –
————————————————-
Just another question: if I recompile this class on Mac, it works.
But if I send it a message with a full macintosh path, like "iBook:/Users/iBook/Desktop/test", that is the path that goes out from "thispatcher" object, it doesn’t create the folder.
However, if I give it a path like "/Users/iBook/Desktop/test", that is without the partition name, it works fine.
On Windows it always works good.
So the questions would be two:
1-Why I have to re-compile this class, if Java is multiplatform?
2-How can I remove the "partition name" from the path, but just on a macintosh platform?
Thank you very much.
Bruno
————————————————-
– –
————————————————-
>
> So the questions would be two:
> 1-Why I have to re-compile this class, if Java is multiplatform?
i am not sure why you are having this problem. it shouldnt be the
case. how are you transferring the class
to the macintosh?
> 2-How can I remove the "partition name" from the path, but just on
> a macintosh platform?
you could try using the function MaxSystem.maxPathToNativePath().
This should translate the max style path
output from thispatcher to something suitable for java.
1-I’m recompiled the class on Macintosh. Now this "new" version seems to work properly boh with OSX and with XP.
2-Thank you very much, this method works perfectly.
Thank you very much for your help.
Bruno
————————————————-
– –
————————————————-
Forums > Java | https://cycling74.com/forums/topic/very-simple-class-file-that-works-only-in-windows/ | CC-MAIN-2016-40 | en | refinedweb |
00001 /* 00002 * Controllable.hpp 00003 * 00004 * Copyright (c) 2000, 2011,_CONTROLLABLE_HPP 00017 #define COH_CONTROLLABLE_HPP 00018 00019 #include "coherence/lang.ns" 00020 00021 #include "coherence/run/xml/XmlElement.hpp" 00022 00023 COH_OPEN_NAMESPACE2(coherence,util) 00024 00025 using coherence::run::xml::XmlElement; 00026 00027 00028 /** 00029 * The Controllable interface represents a configurable dameon-like object, 00030 * quite oftenly referred to as a <i>service</i>, that usually operates on its 00031 * own thread and has a controllable life cycle. 00032 * 00033 * @author jh 2007.12.12 00034 */ 00035 class COH_EXPORT Controllable 00036 : public interface_spec<Controllable> 00037 { 00038 // ----- Controllable interface ----------------------------------------- 00039 00040 public: 00041 /** 00042 * Configure the controllable service. 00043 * 00044 * This method can only be called before the controllable 00045 * service is started. 00046 * 00047 * @param vXml an XmlElement carrying configuration information 00048 * specific to the Controllable object 00049 * 00050 * virtual void IllegalStateException thrown if the service is 00051 * already running 00052 * virtual void IllegalArgumentException thrown if the configuration 00053 * information is invalid 00054 */ 00055 virtual void configure(XmlElement::View vXml) = 0; 00056 00057 /** 00058 * Determine whether or not the controllable service is running. 00059 * This method returns false before a service is started, while 00060 * the service is starting, while a service is shutting down and 00061 * after the service has stopped. It only returns true after 00062 * completing its start processing and before beginning its 00063 * shutdown processing. 00064 * 00065 * @return true if the service is running; false otherwise 00066 */ 00067 virtual bool isRunning() const = 0; 00068 00069 /** 00070 * Start the controllable service. 00071 * 00072 * This method should only be called once per the life cycle 00073 * of the Controllable service. This method has no affect if the 00074 * service is already running. 00075 * 00076 * virtual void IllegalStateException thrown if a service does not 00077 * support being re-started, and the service was 00078 * already started and subsequently stopped and then 00079 * an attempt is made to start the service again; also 00080 * thrown if the Controllable service has not been 00081 * configured 00082 */ 00083 virtual void start() = 0; 00084 00085 /** 00086 * Stop the controllable service. This is a controlled shut-down, 00087 * and is preferred to the {@link #stop()} method. 00088 * 00089 * This method should only be called once per the life cycle of the 00090 * controllable service. Calling this method for a service that has 00091 * already stopped has no effect. 00092 */ 00093 virtual void shutdown() = 0; 00094 00095 /** 00096 * Hard-stop the controllable service. Use {@link #shutdown()} 00097 * for normal service termination. Calling this method for a service 00098 * that has already stopped has no effect. 00099 */ 00100 virtual void stop() = 0; 00101 }; 00102 00103 COH_CLOSE_NAMESPACE2 00104 00105 #endif // COH_CONTROLLABLE_HPP | http://docs.oracle.com/cd/E24290_01/coh.371/e22845/_controllable_8hpp-source.html | CC-MAIN-2016-40 | en | refinedweb |
Hi there, I'm using Boost:Python to extend Python, in order to provide access to some C++ classes I have written. This is working fine - I can load the resulting module in Python, instantiate the classes exported via Boost, and manipulate them and so on. typedef std::map<std::string ,Attr *> attrmap; class Node { std::string name; attrmap attrs; public: Node(std::string name); ~Node(); void addAttr(std::string key, int val); void getAttr(std::string key); } BOOST_PYTHON_MODULE(Node) { using namespace boost::python; class_<Node>("Node",init<std::string>()) .def("addAttr", &Node::addAttr) .def("getAttr", &Node::getAttr) ; } I also have a program which has embedded Python in it. This program can be passed the names of some python files, which it will load and import specific symbols from: filtername = "filter.py"; pName = PyString_FromString(filtermod); pfilterhnd = PyImport_Import(pName); pDict = PyModule_GetDict(pfilterhnd); pfilter = PyDict_GetItemString(pDict, "filter"); And so on. Later on, I then call this filter function: pName = PyString_FromString("name"); pNode = PyString_FromString("node"); pArgs = PyTuple_New(2); PyTuple_SetItem(pArgs, 0, pName); PyTuple_SetItem(pArgs, 1, pNode); pRetVal = PyObject_CallObject(phandler,pArgs); ... Where pArgs is a tuple of arguments. This works fine, as long as I only pass basic Python types to the function - eg, strings (PyString_FromString), longs (PyInt_FromLong) etc. However, I want to be able to pass, into the embedded python, instances (pointers to, actually) the classes which I have exported via Boost. More so, I want the python module I loaded above to be able to modify the datastructure, and have the calling program make use of this. I've imported the appropriate modules into the python interpreter embedded into my C++ program. From what I've read, within the calling C++ program I need to convert (or wrap) the instance of my Node class into a PyObject *. Once I've done that, I can use PyObject_Callfunction or similar to call the python function, passing my Node class into it. Once in there, python will use the boost-extended module to access it. I've been reading mailing lists all day, it seems like this should be very possible, I'm just totally stumped as to how. There's plenty of examples for embedding python into a C/C++ program, and there's plenty of examples for extending python with a C/C++ extension, but there don't seem to be so many which put the two together. Thanks, Daniel | https://mail.python.org/pipermail/cplusplus-sig/2005-January/008181.html | CC-MAIN-2016-40 | en | refinedweb |
Uche Ogbuji <uche.ogbuji at fourthought.com> wrote: > I disagree, and I use CDATA sections a lot. Try writing an article > about XML *in* XML (e.g. XHTML). You might also become a fan :-) I think that's the toolchain's job. In an ideal world there'd be an XML editor that wasn't awful (!) but it's easy enough with a decent text editor to write some XML, select it and encode/decode the offending characters. S'what I do, anyway. :-) > As long as people understand that they're a simple lexical convenience, > I'm not sure what their harm is. You're right: at an XML-parsing level they're not too bad, but still only a rather minor convenience. The problem is that they add complexity without completely solving the problem - if you are writing an XML article about CDATA sections, for example, you can't use a literal ']]>'! > I'm not sure any level of DOM has a sane treatment of CDATA sections I'm with you here, it's the DOM that's the real problem. Aside from normalising text together being defeated by them, the issues with splitting CDATA sections for ']]>' and out-of-encoding characters in DOM3 are an extra annoyance and likely source of bugs for implementations. The legacy nonsense from DTDs is a much worse issue in my book: it turns XML from a simple, easy-to-grok-and-knock-up-a-noddy-parser-for notation into a maze of twisty little bugs, all alike. Manifesto for a cleaner XML more suited to simple tasks (ohmygod Microsoft want to put XML in the DNS argh etc.): - no doctypes DTD validation is underpowered, ineffective for namespaces, and does not deserve to be part of the basic required XML syntax. Validation should be done as a layer on top of XML (Schema, RNG), not as part of the basic required syntax. - no entity references most common use case: named character escapes: character references are almost as convenient and anyway you should be using an encoding that doesn't require you escape them. Further use case: inclusions: use XInclude or similar processing layer on top of XML. Entity references are not worth the *enormous* complexity they add to the DOM (if implemented completely, anyway) - no default attribute values how hard is it for an application to take null (or '') for an answer? - no CDATA sections at least at a DOM level - no attribute normalisation seems to be barely used, and confuses DOM a treat - xmlns: declarations on the root element only, unique URIs being able to reuse prefixes over the document for eg. inclusions is not worth the pain of namespace fixup and broken interaction between DOM1 and DOM2 methods any I missed? Been having a grim day tracking down obscure DOM bugs and interactions, hope everyone is having a fun weekend. I'll stop ranting now then. -- Andrew Clover mailto:and at doxdesk.com | https://mail.python.org/pipermail/xml-sig/2004-May/010277.html | CC-MAIN-2016-40 | en | refinedweb |
Mic wrote: >>I chose to ignore the "using classes" part. If you like you can turn the >>button_clicked() function into a method of a subclass of Button. You can >>also move the Button configuration done in create_widgets() into the >>__init__() method of that subclass. > > import tkinter as tk > from functools import partial > > def button_clicked(button): > if button["bg"] == "green": > button.configure(bg="red", text="Hi 2") > else: > button.configure(bg="green", text="Hi 1") > > class Window(tk.Frame): > def __init__(self, master): > super (Window, self).__init__(master) > self.grid() > self.create_widgets() > > def create_widgets(self): > for _ in range(2): > button = tk.Button(self) > command = partial(button_clicked, button) > button["command"] = command > button.grid() > command() > > root = tk.Tk() > root.title("Test") > root.geometry("200x200") > app = Window(root) > root.mainloop() > A very elegant solution. Much better than my previous one. However, I am a > bit unfamiliar with your way of > coding, I assume you are used to a version other than Python 3.2? Yes, though I don't think the difference between 2.x and 3.x matters here. > Because, never before have I seen either of those Most tkinter tutorials seem to use from tkinter import * which I don't like because it doesn't make explict which names are put into the current module's namespace. The alternative import tkinter leads to long qualified names. > import tkinter as tk is a popular compromise. > from functools import partial I use this kind of explicit import for a few names that I use frequently, namely defaultdict, contextmanager, everything from itertools... I think of these as my personal extended set of builtins ;) As to the actual partial() function, you probably don't see it a lot because it has been in the standard library for only three years. The older idiom for making a function that calls another function with a fixed argument is command = lambda button=button: button_clicked(button) > I also wonder, if I implement your solution, is there anyway I can place > the buttons in the program as I would like, or will they be played in a > straight, vertical row > always? You can iterate over (row, column) pairs instead of the dummy _ variable: def create_widgets(self): for row, column in [(0, 0), (1, 1), (2, 2), (3, 0)]: button = tk.Button(self) command = partial(button_clicked, button) button["command"] = command button.grid(row=row, column=column) command() > Also, assume that I have a already have a window with a button in it. If > you press this button, this window is supposed to open. > So, if I press the button, will this window open? Because I created the > previous window using > from tkinter import* and not import tkinter as tk. You can make the decision what style you want to use on a per-module basis. In that module you can then access (for example) a tkinter button with either tkinter.Button, tk.Button or just Button. You can even mix styles if you put the respective imports at the beginning of the module (not recommended). What approach you take has no consequences on the execution of the program. > I hope my English is understandable, because it is not my primary > language. Thanks for your help, it is greatly appreciated! Many posters aren't native speakers, so you can never be sure that what you pick up here is actually English ;) I didn't have any problems with your command of the language, but I'm not a native speaker either. | https://mail.python.org/pipermail/tutor/2011-November/086966.html | CC-MAIN-2016-40 | en | refinedweb |
]>
NAME
SYNOPSIS
DESCRIPTION
DIAGNOSTICS
SEE ALSO
XGrabDevice, XUngrabDevice − grab/release the specified extension device
#include <X11/extensions/XInput.h>events.DeviceEvents−device−grab time or later than the current X server
time, it fails and returns GrabInvalidTime. Otherwise, the
last−device−grab specified time
is earlier than the last−device−grab time or is later than the
current X server time. It also generates DeviceFocusIn and
DeviceFocusOut events. The X server automaticallyButton(3), XGrabDeviceKey(3) | https://www.x.org/releases/current/doc/man/man3/XGrabDevice.3.xhtml | CC-MAIN-2016-40 | en | refinedweb |
This is the mail archive of the [email protected] mailing list for the libstdc++ project.
Hi, > Hello, I would like to know if this is correct. I'm using a recent svn > version of gcc (maybe 2 weeks ago or so): > > > #include <string> > #include <iostream> > > > int main() { > using namespace std; > > > cout << stoi("0xff") << endl; > > cout << to_string(static_cast<long long>(10)) << endl; > } > > > In this program, stoi returns 0. Is this correct? I think it should > throw an exception std::invalid_argument or interpret this as hex. > The implementation is straightforward, just uses strtol, per the CD standard. Please have a look to the implementation in ext/string_conversions.h. I think the way libstdc++ uses the underlying strtol is correct, the remaining issues can only be due to non-conforming behavior of the underlying strtol (like, to explain what I mean,). Let me know, anyway... > It's my guess, anyway I haven't > read what the standard says about it. And to_string causes ambiguity. > Is this because of c++ overloading? Do I really need to cast? Thanks. > In this case really no doubt we are implementing the CD literally, three overloads, for long long, unsigned long long, long double. Paolo. | http://gcc.gnu.org/ml/libstdc++/2008-10/msg00119.html | crawl-003 | en | refinedweb |
mitem_opts(3) UNIX Programmer's Manual mitem_opts(3)
mitem_opts - set and get menu item options
#include <menu.h> int set_item_opts(ITEM *item, OPTIONS opts); int item_opts_on(ITEM *item, OPTIONS opts); int item_opts_off(ITEM *item, OPTIONS opts); OPTIONS item_opts(const ITEM *item);.
Except for item_opts, each routine returns one of the fol- lowing: E_OK The routine succeeded. E_SYSTEM_ERROR System error occurred (see err. | http://mirbsd.mirsolutions.de/htman/sparc/man3/item_opts.htm | crawl-003 | en | refinedweb |
mitem_name(3) UNIX Programmer's Manual mitem_name(3)
mitem_name - get menu item name and description fields
#include <menu.h> const char *item_name(const ITEM *item); const char *item_description(const ITEM *item);
The function item_name returns the name part of the given item. The function item_description returns the description part of the given item.
These routines returns NULL on. | http://mirbsd.mirsolutions.de/htman/sparc/man3/item_description.htm | crawl-003 | en | refinedweb |
.
To summarize the interface (
key is a string,
data is an
arbitrary object):
import shelve d = shelve.open(filename) # open, with (g)dbm filename -- no suffix d[key] = data # store data at key (overwrites old data if # using an existing key) data = d[key] # retrieve data at key (raise KeyError if no # such key) del d[key] # delete data stored at key (raises KeyError # if no such key) flag = d.has_key(key) # true if the key exists list = d.keys() # a list of all existing keys (slow!) d.close() # close it
Restrictions:
See Also:
dbm-style databases.
dbdatabase interface.
dbminterface.
dbminterface. | http://docs.python.org/release/2.1.3/lib/module-shelve.html | crawl-003 | en | refinedweb |
Preventing ESC in Full Screen Interactive
Penultimate post on the AIR 1.5.2 update: Prior to AIR 1.5.2, if a user hit the escape key when an application was running in fullScreen or fullScreenInteractive, the application would be forced out of full screen mode. This remains the intended behavior for fullScreen, but was a defect in the implementation of fullScreenInteractive.
Starting with AIR 1.5.2, hitting escape causes fullScreenInteractive to exit by default but the behavior can be canceled by calling preventDefault() on the keydown event. Applications that use full screen to keep users (perhaps kids) from too easily leaving the application may find this change useful. As always, remember to update your namespace to take advantage of this new behavior. | http://blogs.adobe.com/simplicity/2009/08 | crawl-003 | en | refinedweb |
IntroductionMany developers finding a way how to show Parent child records in windows form like ms access show like expand and collapse records .In this article I am going to teach you that same thing how show such records in hierarchical view .Our Target:Technologies:ADO.NET 2.0/3.5, Window Forms.Prerequisites:Knowledge of ADO.NET and knowledge of basic Database connectivity.ImplementationNow you have seen the above screen shot and knowing what we are going to build which is something similar to ms access's Data Display. So let's get started!First of all we need to create 2 Sample Table for whose data we are going to display onto our form !!In application make Two Tables for instance:Here in User Data Table Is master table while User Detail Table is Child Table.Now we are gonna use some old stuff here that is DataGrid Control. Because dataGridView Control is not supporting the hierarchical view of data, so let's add DataGrid Control to your tool box by Right Click in tool Box >>Choose Items And Choose Data Grid there:Now Click OK.You will have new Control Called DataGrid in your Tool Box Drag and Drop it on the Form like normal DataGridView.Now do connectivity Like below :Everything in code I have mentioned by comment what it does! so you can understand it easily.General steps I have done in code:
using System.Data.SqlClient;
namespace WindowsFormsApplication12
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void Form1_Load(object sender, EventArgs e)
SqlConnection con = new SqlConnection(@"Data Source=.\SQLEXPRESS;AttachDbFilename=|DataDirectory|\Database1.mdf;Integrated Security=True;User Instance=True");
con.Open();
SqlCommand comm = new SqlCommand("select * from UserData",con);
DataTable master = new DataTable();
DataTable child = new DataTable();
// Fill Table 2 with Data
SqlDataAdapter da = new SqlDataAdapter(comm);
da.Fill(master);
// Fill Table1 with data
comm = new SqlCommand("select * from UserDetail",con);
da.Fill(child);
con.Close();
DataSet ds = new DataSet();
//Add two DataTables in Dataset
ds.Tables.Add(master);
ds.Tables.Add(child);
// Create a Relation in Memory
DataRelation relation = new DataRelation("",ds.Tables[0].Columns[0],ds.Tables[1].Columns[0],true);
ds.Relations.Add(relation); // Set DataSource dataGrid1.DataSource = ds.Tables[0]; } }}F5 to run project! and you can now collapse and expands records in Hierarchical View.That's it! You have achieved what you wanted! without using any third party controls.Though now days in there are many vendors that provide better Hierarchical view Data Controls than this old DataGrid Control like major vendors are devExpress , Telerik RAD controls etc, that can provide better feature than, many more options also for data binding .ConclusionThis article teaches about how to showing parent/child relationship between two table records in single grid view.
Show Parent Child Records in Windows Form like Ms Access
Create Windows Application in C# from Command Line
Hi Kirtan,Good Article.Explained in simple yet powerful language.Very Helpful...But, I'm facing same problem in my project.I have used Collection instead of Dataset.So, Is it possinle to Show Relation in between Collection??? | http://www.c-sharpcorner.com/uploadfile/kirtan007/show-parent-child-records-in-windows-form-like-ms-access/ | crawl-003 | en | refinedweb |
MOUNT_KERNFS(8) BSD System Manager's Manual MOUNT_KERNFS(8)
mount_kernfs - mount the /kern file system
mount_kernfs [-o options] /kern mount_point
The mount_kernfs command attaches an instance of the kernel parameter namespace to the global filesystem namespace. The conventional mount point is /kern. This command is invoked by mount(8) when using the syntax mount [options] -t kernfs /kern mount_point This command is normally executed by mount(8) at boot time. The filesystem includes several regular files which can be read, some of which can also be written. The contents of the files are in a machine- independent format, either a string, or an integer in decimal ASCII. Where numbers are returned, a trailing newline character is also added. The options are as follows: -o options Options are specified with a -o flag followed by a comma separat- ed string of options. See the mount(8) man page for possible op- tions and their meanings. Statistics reported by df(1) on the /kern filesystem will indicate the amount of unwired/physical memory instead of 'disk space', and the number of vnodes used/allocated instead of 'inodes'. The filesystem's block size is the system's page size.
boottime Time at which the system was last booted (decimal ASCII). byteorder _BYTE_ORDER for this kernel. copyright Kernel copyright message. domainname The domainname, with a trailing newline. Behaves like a host- name. hostname The hostname, with a trailing newline. The hostname can be changed by writing to this file. A trailing newline will be stripped from the hostname being written. hz Frequency of the system clock (decimal ASCII). ipsec The currently configured IPsec Security Associations. loadavg The 1, 5 and 15 minute load average in kernel fixed-point format. The final integer is the fix-point scaling factor. All numbers are in decimal ASCII. machine Architecture this kernel was compiled for. model Model of the processor this machine is running on. msgbuf Kernel message buffer, also read by syslogd(8), through the log device, and by dmesg(8). ncpu Number of CPUs in this machine. osrelease OS release number. osrev OS revision number (BSD from <sys/param.h>). ostype OS type for this kernel ("OpenBSD"). pagesize Machine pagesize (decimal ASCII). physmem Number of pages of physical memory in the machine (decimal ASCII). posix _POSIX_VERSION for this kernel. rootdev Root device. rrootdev Raw root device. time Second and microsecond value of the system clock. Both numbers are in decimal ASCII. usermem Number of pages of physical memory available for user processes. version Kernel version string. The head line for /etc/motd can be generated by running: "sed 1q /kern/version".
mount(2), fstab(5), dmesg(8), mount(8), syslogd(8), umount(8)
The mount_kernfs utility first appeared in 4.4BSD.
This filesystem may not be NFS-exported. Due to non-atomic operations and the potential for race conditions, pro- grams should not depend on information obtained from this filesystem.. | http://mirbsd.mirsolutions.de/htman/sparc/man8/mount_kernfs.htm | crawl-003 | en | refinedweb |
MOUNT_FDESC(8) BSD System Manager's Manual MOUNT_FDESC(8)
mount_fdesc - mount the file-descriptor file system
mount_fdesc [-o options] fdesc mount_point
The mount_fdesc command attaches an instance of the per-process file descriptor namespace to the global filesystem namespace. The conventional mount point is /dev and the filesystem should be union mounted in order to augment, rather than replace, the existing entries in /dev. This com- mand is invoked by mount(8) when using the syntax mount [options] -t fdesc fdesc mount_point This command is normally executed by mount(8) at boot time. The options are as follows: -o options Options are specified with a -o flag followed by a comma separat- ed string of options. See the mount(8) man page for possible op- tions ex- actly the same way as the real controlling terminal device.
/dev/fd/# /dev/stdin /dev/stdout /dev/stderr /dev/tty
mount(2), tty(4), fstab(5), mount(8), umount(8)
The mount_fdesc utility first appeared in 4.4BSD.
This filesystem may not be NFS-exported.. | http://mirbsd.mirsolutions.de/htman/sparc/man8/mount_fdesc.htm | crawl-003 | en | refinedweb |
Many 1.4). And it means that symbols that should be accessible from other extension modules must be exported in a different way.
Python provides a special mechanism to pass C-level information (pointers) from one extension module to another one: CObjects. A CObject is a Python data type which stores a pointer (void *). CObjects CObject.
There are many ways in which CObjects can be used to export the C API of an extension module. Each name could get its own CObject, or all C API pointers could be stored in an array whose address is published in a CObject. And the various tasks of storing and retrieving the pointers can be distributed in different ways between the module providing the code and the client modules. CObject. The header file corresponding to the module provides a macro that takes care of importing the module and retrieving its C API pointers; client modules only have to call this macro before accessing the C API.
The exporting module is a modification of the spam module from section 1.1.(command) char *command; { return system(command); }
The function spam_system() is modified in a trivial way:
static PyObject * spam_system(self, args) PyObject *self; PyObject *args; {:
void initspam(void) { PyObject *m; static void *PySpam_API[PySpam_API_pointers]; PyObject *c_api_object; m = Py_InitModule("spam", SpamMethods); /* Initialize the C API pointer array */ PySpam_API[PySpam_System_NUM] = (void *)PySpam_System; /* Create a CObject containing the API pointer array's address */ c_api_object = PyCObject_FromVoidPtr((void *)PySpam_API, NULL); if (c_api_object != NULL) { /* Create a name for this object in the module's namespace */ PyObject *d = PyModule_GetDict(m); PyDict_SetItemString(d, "_C_API", c_api_object); Py_DECREF]) #define import_spam() \ { \ PyObject *module = PyImport_ImportModule("spam"); \ if (module != NULL) { \ PyObject *module_dict = PyModule_GetDict(module); \ PyObject *c_api_object = PyDict_GetItemString(module_dict, "_C_API"); \ if (PyCObject_Check(c_api_object)) { \ PySpam_API = (void **)PyCObject_AsVoidPtr(c_api_object); \ } \ } \ } #endif #ifdef __cplusplus } #endif #endif /* !defined(Py_SPAMMODULE_H */
All that a client module must do in order to have access to the function PySpam_System() is to call the function (or rather macro) import_spam() in its initialization function:
void initclient(void) { PyObject *m; Py_InitModule("client", ClientMethods); import_spam(); }
The main disadvantage of this approach is that the file spammodule.h is rather complicated. However, the basic structure is the same for each function that is exported, so it has to be learned only once.
Finally it should be mentioned that CObjects offer additional functionality, which is especially useful for memory allocation and deallocation of the pointer stored in a CObject. The details are described in the Python/C API Reference Manual in the section ``CObjects'' and in the implementation of CObjects (files Include/cobject.h and Objects/cobject.c in the Python source code distribution).See About this document... for information on suggesting changes. | http://docs.python.org/release/2.2p1/ext/using-cobjects.html | crawl-003 | en | refinedweb |
#include <itkObjectStore.h>
A specialized memory management object for allocating and destroying contiguous blocks of objects..
Definition at line 63 of file itkObjectStore.h.
Reimplemented from itk::Object.
Definition at line 70 of file itkObjectStore.h.
Type of list for storing pointers to free memory.
Definition at line 82 of file itkObjectStore.h.
Type of the objects in storage.
Definition at line 76 of file itkObjectStore.h.
Reimplemented from itk::Object.
Definition at line 69 of file itkObjectStore.h.
Standard typedefs.
Reimplemented from itk::Object.
Definition at line 67 of file itkObjectStore.h.
Reimplemented from itk::Object.
Definition at line 68 of file itkObjectStore.h.
Type of memory allocation strategy
Definition at line 85 of file itkObjectStore.h.
Set growth strategy to linear
Set growth strategy to linear
Borrow a pointer to an object from the memory store.
Frees all memory in the container.
Returns a new size to grow.
Set/Get the growth strategy.
Set/Get the linear growth size
Run-time type information (and related methods).
Reimplemented from itk::Object.
Returns the size of the container. This is not the number of objects available, but the total number of objects allocated.
Method for creation through the object factory.
Reimplemented from itk::Object.
Mutex lock to protect modification to the reference count
Reimplemented from itk::Object.
Set growth strategy to linear
Reimplemented from itk::Object.
Ensures that there are at least n elements allocated in the storage container. Will not shrink the container, but may enlarge the container.
Return a pointer to the memory store for reuse. WARNING: The ObjectStore assumes a pointer is returned exactly once after each time it has been borrowed.
Set/Get the growth strategy.
Set growth strategy to exponential
Definition at line 122 of file itkObjectStore.h.
Set growth strategy to linear
Definition at line 126 of file itkObjectStore.h.
Set/Get the linear growth size
Attempts to free memory that is not in use and shrink the size of the container. Not guaranteed to do anything.
Pointers to objects available for borrowing.
Definition at line 161 of file itkObjectStore.h.
Definition at line 155 of file itkObjectStore.h.
Definition at line 158 of file itkObjectStore.h.
Definition at line 157 of file itkObjectStore.h.
A list of MemoryBlocks that have been allocated.
Definition at line 164 of file itkObjectStore.h. | http://www.itk.org/Insight/Doxygen/html/classitk_1_1ObjectStore.html | crawl-003 | en | refinedweb |
In Microsoft Content Management System 2002, if the state of the posting is not saved, after releasing the lock on a posting using the API, it will change the state back to Saved. Microsoft has stated this as a bug in the system. I had a situation in which I really needed to release the lock without the state change. At last I figured out an ugly way to achieve this.
<?xml:namespace prefix = o
It directly changes the owner of the posting in the database (ugly). Because it is a direct database change, the server cache must be cleared in SCA to see the changes. By passing the GUID of the posting, the relevant Node is taken from the database and the owner of the posting is changed.
dataConfiguration.config file must be modified to point out the MCMS database name and server name.
<parameter name="database" value="mcmsdatabase" isSensitive="false" />
<parameter name="server" value="mcmsserver" isSensitive="false" />
Even though it works fine for me, please do check before using this. Because this is a direct database change, you must be very careful before using this.
N.B: Unfortunately, direct access to the MCMS database without using the MCMS publishing API breaks the Microsoft Support Boundaries for MCMS. So, if you are interested in using Microsoft Support, please don't use this.
This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.
A list of licenses authors might use can be found here | http://www.codeproject.com/Articles/9848/Release-Ownership-in-MCMS-2002 | crawl-003 | en | refinedweb |
Make WordArt, like the ones in MS Office, using Python3
Project description
pythonWordArt
Make WordArt, like the ones in MS Office, using Python3.
The actual WordArt generation is performed by a forked version of CSS3 WordArt by Arizzitano (), this Python class is just producing the correct HTML code, rendering it into a Qt widget, and then saving into a PNG image. Basically, the HTML get rendered by a QWebEngineView which is not being shown on screen. Then, the widget contents get stored into a PNG image and cropped in order to oly include the actual WordArt. It's also possible to get a transparent background.
Requirements
- PySide2:
If you install pythonWordArt with pip
pip install pythonWordArt
the PySide2 library will be installed automatically. Anyway, if you are installing this on a Linux server, you might need to install also these libraries using your package manager:
sudo apt-get install libgl1-mesa-dri libgl1-mesa-glx libnss3 libfontconfig1 libxcomposite1 libxcursor1 libxi6 libxtst6 libasound2
you don't need a full Xorg running, just the base libraries. The only problem is that if you don't have a Xorg screen you cannot use the OpenGL effects, so a handful of WordArt styles will not be available. You can check that running the demo.
Simple test
If you run the main.py file it will print the name a temporary folder: all the files for the demo will be created in that folder.
It's also available a test program that you can run without arguments, or with two arguments. For example, if you want to create an image called example.png using the style rainbow just run this:
python3 test.py example.png rainbow
if you want to know all styles name, please keep reading.
Example code
This is a minimalistic example:
from pythonWordArt import pyWordArt w = pyWordArt() w.WordArt("Text here", w.Styles[mystyle], "100") w.toFile(fileName)
The first argument is the text, the second is the Style (which needs to be choosen from the Styles list, but it's a number from 0 to 29) and the third is the size of the font used to write the WordArt. Usually, 100 is a good value. This gives you a pyWordArt object, that you can then write to an image file (usually in PNG) using the toFile function.
Alternatively, you can get the image as a Base64 coded text, thanks to the toBase64 function.
It's also possibile to obtain an input-output buffer, useful for libraries that need to open buffers like PIL o Telepot. For example, it can be used like this:
from PIL import Image from pythonWordArt import pyWordArt w = pyWordArt() w.WordArt("Text here", w.Styles[mystyle], "100") pil_im = Image.open(w.toBufferIO()) pil_im.show()
If you specify the noOpenGL as True, the library will load with minimal graphic support, without an OpenGL context to render 3D effects. If you don't specify this flag, the rendering will be done with OpenGL if available.
To try out all the styles, you can run a demo:
import tempfile import os from pythonWordArt import pyWordArt w = pyWordArt() # Creating a temporary folder tmpdirname = "" with tempfile.TemporaryDirectory() as dirname: tmpdirname = dirname os.mkdir(tmpdirname) print(tmpdirname) # Set drawing canvas size, optional but recommended w.canvasWidth = 1754 w.canvasHeight = 1240 # Run the demo w.demo(tmpdirname, 100)
It's a good idea to set the canvas size, in particular if you are writing a long text. A note: running the demo, some images might not be written correctly. This happens because some WordArt need some more time, and if you create too many one after the other the QWebEngineView does not have the time to clear its content. This does not happen if you wait between the creation of two WordArt.
If you need to get the background transparent, you can set
w.transparentBackground = True
before calling the function WordArt or demo.
Styles
These are all the available styles:
- outline
- up
- arc
- squeeze
- inverted-arc
- basic-stack
- italic-outline
- slate
- mauve
- graydient
- red-blue
- brown-stack
- radial
- purple
- green-marble
- rainbow
- aqua
- texture-stack
- paper-bag
- sunset
- tilt
- blues
- yellow-dash
- green-stack
- chrome
- marble-slab
- gray-block
- superhero
- horizon
- stack-3d
You can find all the images in the examples folder.
List of members
Functions:
init__(self, text = "WordArt Test", style = 15, size = 100, noOpenGL = False)
This function initialize the pythonWordArt object. It's possible to call the function with no argoments, and set the basic properties in the next lines of code. Or you can already set the properties here, which is useful if you just want to get one single wordart. Does not return a value.
WordArt(self, wordartText, wordartStyle, wordartSize)
This function enables you to set new properties for a WordArt. Basically, you can change the text, the style, or the size all in one line. If you prefer, it's also possible to set the properties manually. Does not return a value.
toHTML(self, wordartText, wordartStyle, wordartSize)
Returns a string containing html code that works locally displaying the WordArt.
toBase64()
Returns the wordart image as a printable string text in Base64 encoding.
toBufferIO()
Returns an Input Output buffer containing the image. This simulates opening a file withotu actually having to write a file on disk.
toFile(fileName)
Saves the image in a file. The name fileName can be with or without extension. If the extension is missing, PNG format will be used automatically. Returns full fileName.
demo(self, dirName, wordartSize = 100)
This function take a folder path, and eventually the WordArt size, as arguments. It then creates as many wordart files (in PNG format) as the available Styles. Does not return a value.
Properties:
noOpenGL = bool
By default set to False. If set to True, the WordArt creation will be performed without OpenGL, which means some Styles will not look good but you'll be able to use it even if you are running it headless without a GPU.
transparentBackground = bool
By default set to False. If set to True, the WordArt background will become transaprent. If wiriting to a file, please remember to use a format that supports transparency, like PNG.
canvasWidth = int
By default set to 1754, an A4 page width at 150dpi. It is the width in pixels of the canvas where the WordArt will be drawn: you need to set it accordingly to the length of the text you are going to write. In the future, it will be adjusted automatically.
canvasHeight = int
By default set to 1240, an A4 page height at 150dpi. It is the height in pixels of the canvas where the WordArt will be drawn: you need to set it accordingly to the length of the text you are going to write. In the future, it will be adjusted automatically.
text = str
This is the text of the WordArt. Just set whatever you want, but take note that shot texts, less than 3 or 4 words, work best.
style = int
This is the style of the WordArt, by default it's 15, which is the rainbow style. Take a look at the styles list.
size = int
This is the size of the WordArt, by default it's 100. If you need a bigger image, ust use a bigger number.
Styles = dict
This dictionary contains all the styles supported by pythonWordArt. It's easyer to remember the styles by their name nstead of the number.
HTML
There is a simple HTML example in the pythonWordArt folder, of course you need also the css3wordart subfolder to make it work. To change the text, just look for the wordart-text span. The content of the span will become the text, and the the data-text property will become the shadow. Usually, text and shadow are the same, but you can always use different phrases.
Thanks to
Arizzitano for his WordArt in CSS3+Javascript:
The Qt Company for PySide2
Project details
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages. | https://pypi.org/project/pythonWordArt/ | CC-MAIN-2019-47 | en | refinedweb |
Artifact fc8c51f0b61bc803ccdec092e130bebe762b0a2f:
- File src/encode.c — part of check-in [0a12473c] at 2004-03-17 18:44:46 on branch trunk — The sqlite_trace() API only works for commands started by the user, not for SQL commands run during initialization. (CVS 1298) (user: drh size: 8974)
/* ** not used by any other ** part of the SQLite library. ** ** $Id: encode.c,v 1.12 2004/03/17 18:44:46 drh Exp $ */ #include <string.h> #include <assert.h> /* ** How This Encoder Works ** ** The output is allowed to contain any character except 0x27 (') and ** 0x00. This is accomplished by using an escape character to encode ** 0x27 and 0x00 as a two-byte sequence. The escape character is always ** 0x01. An 0x00 is encoded as the two byte sequence 0x01 0x01. The ** 0x27 character is encoded as the two byte sequence 0x01 0x28. Finally, ** the escape character itself is encoded as the two-character sequence ** 0x01 0x02. ** ** To summarize, the encoder works by using an escape sequences as follows: ** ** 0x00 -> 0x01 0x01 ** 0x01 -> 0x01 0x02 ** 0x27 -> 0x01 0x28 ** ** If that were all the encoder did, it would work, but in certain cases ** it could double the size of the encoded string. For example, to ** encode a string of 100 0x27 characters would require 100 instances of ** the 0x01 0x03 escape sequence resulting in a 200-character output. ** We would prefer to keep the size of the encoded string smaller than ** this. ** ** To minimize the encoding size, we first add a fixed offset value to each ** byte in the sequence. The addition is modulo 256. (That is to say, if ** the sum of the original character value and the offset exceeds 256, then ** the higher order bits are truncated.) The offset is chosen to minimize ** the number of characters in the string that need to be escaped. For ** example, in the case above where the string was composed of 100 0x27 ** characters, the offset might be 0x01. Each of the 0x27 characters would ** then be converted into an 0x28 character which would not need to be ** escaped at all and so the 100 character input string would be converted ** into just 100 characters of output. Actually 101 characters of output - ** we have to record the offset used as the first byte in the sequence so ** that the string can be decoded. Since the offset value is stored as ** part of the output string and the output string is not allowed to contain ** characters 0x00 or 0x27, the offset cannot be 0x00 or 0x27. ** ** Here, then, are the encoding steps: ** ** (1) Choose an offset value and make it the first character of ** output. ** ** (2) Copy each input character into the output buffer, one by ** one, adding the offset value as you copy. ** ** (3) If the value of an input character plus offset is 0x00, replace ** that one character by the two-character sequence 0x01 0x01. ** If the sum is 0x01, replace it with 0x01 0x02. If the sum ** is 0x27, replace it with 0x01 0x03. ** ** (4) Put a 0x00 terminator at the end of the output. ** ** Decoding is obvious: ** ** (5) Copy encoded characters except the first into the decode ** buffer. Set the first encoded character aside for use as ** the offset in step 7 below. ** ** (6) Convert each 0x01 0x01 sequence into a single character 0x00. ** Convert 0x01 0x02 into 0x01. Convert 0x01 0x28 into 0x27. ** ** (7) Subtract the offset value that was the first character of ** the encoded buffer from all characters in the output buffer. ** ** The only tricky part is step (1) - how to compute an offset value to ** minimize the size of the output buffer. This is accomplished by testing ** all offset values and picking the one that results in the fewest number ** of escapes. To do that, we first scan the entire input and count the ** number of occurances of each character value in the input. Suppose ** the number of 0x00 characters is N(0), the number of occurances of 0x01 ** is N(1), and so forth up to the number of occurances of 0xff is N(255). ** An offset of 0 is not allowed so we don't have to test it. The number ** of escapes required for an offset of 1 is N(1)+N(2)+N(40). The number ** of escapes required for an offset of 2 is N(2)+N(3)+N(41). And so forth. ** In this way we find the offset that gives the minimum number of escapes, ** and thus minimizes the length of the output string. */ /* ** Encode a binary buffer "in" of size n bytes so that it contains ** no instances of characters '\'' or '\000'. The output is ** null-terminated and can be used as a string value in an INSERT ** or UPDATE statement. Use sqlite_decode_binary() to convert the ** string back into its original binary. ** ** The result is written into a preallocated output buffer "out". ** "out" must be able to hold at least 2 +(257*n)/254 bytes. ** In other words, the output will be expanded by as much as 3 ** bytes for every 254 bytes of input plus 2 bytes of fixed overhead. ** (This is approximately 2 + 1.0118*n or about a 1.2% size increase.) ** ** The return value is the number of characters in the encoded ** string, excluding the "\000" terminator. ** ** If out==NULL then no output is generated but the routine still returns ** the number of characters that would have been generated if out had ** not been NULL. */ int sqlite_encode_binary(const unsigned char *in, int n, unsigned char *out){ int i, j, e, m; unsigned char x; int cnt[256]; if( n<=0 ){ if( out ){ out[0] = 'x'; out[1] = 0; } return 1; }; } } if( out==0 ){ return n+m+1; } out[0] = e; j = 1; for(i=0; i<n; i++){ x = in[i] - e; if( x==0 || x==1 || x=='\''){ out[j++] = 1; x++; } out[j++] = x; } out[j] = 0; assert( j==n+m+1 ); return j; } /* ** Decode the string "in" into binary data and write it into "out". ** This routine reverses the encoding, e; unsigned char c; e = *(in++); i = 0; while( (c = *(in++))!=0 ){ if( c==1 ){ c = *(in++) - 1; } out[i++] = c + e; } return i; } #ifdef ENCODER_TEST #include <stdio.h> /* ** The subroutines above are not tested by the usual test suite. To test ** these routines, compile just this one file with a -DENCODER_TEST=1 option ** and run the result. */ int main(int argc, char **argv){ int i, j, n, m, nOut, nByteIn, nByteOut; unsigned char in[30000]; unsigned char out[33000]; nByteIn = nByteOut = 0; for(i=0; i<sizeof(in); i++){ printf("Test %d: ", i+1); n = rand() % (i+1); if( i%100==0 ){ int k; for(j=k=0; j<n; j++){ /* if( k==0 || k=='\'' ) k++; */ in[j] = k; k = (k+1)&0xff; } }else{ for(j=0; j<n; j++) in[j] = rand() & 0xff; } nByteIn += n; nOut = sqlite_encode_binary(in, n, out); nByteOut += nOut; if( nOut!=strlen(out) ){ printf(" ERROR return value is %d instead of %d\n", nOut, strlen(out)); exit(1); } if( nOut!=sqlite_encode_binary(in, n, 0) ){ printf(" ERROR actual output size disagrees with predicted size\n"); exit(1); } m = (256*n + 1262)/253; printf("size %d->%d (max %d)", n, strlen(out)+1,"); } fprintf(stderr,"Finished. Total encoding: %d->%d bytes\n", nByteIn, nByteOut); fprintf(stderr,"Avg size increase: %.3f%%\n", (nByteOut-nByteIn)*100.0/(double)nByteIn); } #endif /* ENCODER_TEST */ | https://sqlite.org/src/artifact/fc8c51f0b61bc803 | CC-MAIN-2019-47 | en | refinedweb |
I am trying to use IDEA’s flex compiler and am having some trouble with it. My project is setup with 2 modules: 1)a flex client module and 2)a java server module with spring and web facets. I am building the java module with my ant script, but want to use IDEA’s builder for the flex module. The flex compiler settings has a place for the “Main class”. It’s a webapp project, and a flex module to boot, so does not have a class with a main() method in the application. Without the Main class set, running the flex module results in a popup prompting me to choose a Main class. Any suggestion/insight out there would be appreciated. I've attached snapshots of the flex compiler settings and the run/debug configuration for the flex module.
I am using the Maia build 90.116. Is the video demo’ing working with flex in Maia available yet?
Thanks,
-Mary
Attachment(s):
runDebugConfiguration.docx
flexCompilerSetting.docx
Main class in Flex is not the class that has main() method. It is usually a class (defined either in *.as or in *.mxml file) that is inherited from mx.core.Application or mx.modules.Module class.
Main class is a Flex compilation setting so whatever gui or command line tool you use to compile Flex - in any case you specify main Flex class or file with main Flex class.
That would be a file named "video.mxml". However, when I tried to specify that file in the Choose Main Class popup of the Flex Compiler Settings, the OK button remains disabled. What is there to do?
-Mary
Welcome to Flex language programming
Mxml files define Flex classes. The name of the class is equal to the name of the *.mxml file without extension. Root tag (like <mx:Application/>) specifies parent class (as if you have wrote public class video extends mx.core.Application{...})
By the way Flex coding conventions recommend to start class name with an uppercase letter:
So the answer is 'video' - this is the name of your main class.
By the way the text field 'Main class' in Flex Compiler Settings has a button to the right from it - it opens class chooser and suggests correct main class for you.
Yes, I tried using the "..." control next to the textbox, but as you can see from my attached file, the OK button remains disabled in both the Search by Name and the Project tab, indicating that the video.mxml file is not acceptable. I also tried just typing in "video" in the textbox, but at runtime, I am told that there is a Flex Compiler Problem of "Main class 'video' for module 'video_flex' is not found.". What else do I need to do?
Thanks,
-Mary
Attachment(s):
chooseMainClass.docx
At your screenshot I see that flex_src folder is marked as a library home. But it should be you source folder.
Please open 'Sources' tab for your Flex module settings and configure flex_src to be your source root. Then after pressing OK and indexing complete you'll be able to select 'video' class as main class. If you still face any problems please attach screenshot of 'Sources' and 'Dependencies' tabs. | https://intellij-support.jetbrains.com/hc/en-us/community/posts/206836965-using-Maia-s-flex-compiler?page=1 | CC-MAIN-2019-47 | en | refinedweb |
table of contents
- buster 4.16-2
- buster-backports 5.02-1~bpo10+1
- testing 5.03-1
- unstable 5.03-1
NAME¶readdir - read a directory
SYNOPSIS¶
#include <dirent.h>
struct dirent *readdir(DIR *dirp);
DESCRIPTION¶The.
RETURN VALUE¶. To distinguish end of stream and from an error, set errno to zero before calling readdir() and then check the value of errno if NULL is returned.
ERRORS¶
- EBADF
- Invalid directory stream descriptor dirp.
ATTRIBUTES¶For an explanation of the terms used in this section, see attributes(7).
In the current POSIX.1 specification (POSIX.1-2008), readdir() is not required to be thread-safe. However, in modern implementations (including the glibc implementation), concurrent calls to readdir() that specify different directory streams are thread-safe. In cases where multiple threads must read from the same directory stream, using readdir() with external synchronization is still preferable to the use of the deprecated readdir_r(3) function. It is expected that a future version of POSIX.1 will require that readdir() be thread-safe when concurrently employed on different directory streams.
CONFORMING TO¶POSIX.1-2001, POSIX.1-2008, SVr4, 4.3BSD.
NOTES¶AThe. | https://manpages.debian.org/buster-backports/manpages-dev/readdir.3.en.html | CC-MAIN-2019-47 | en | refinedweb |
![if !IE]> <![endif]>
Mapping
Often it is useful to map the elements of one stream to another. For example, a stream that contains a database of name, telephone, and e-mail address information might map only the name and e-mail address portions to another stream. As another example, you might want to apply some transformation to the elements in a stream. To do this, you could map the transformed elements to a new stream. Because mapping operations are quite common, the stream API provides built-in support for them. The most general mapping method is map( ). It is shown here:
<R> Stream<R> map(Function<? super T, ? extends R> mapFunc)
Here, R specifies the type of elements of the new stream; T is the type of elements of the invoking stream; and mapFunc is an instance of Function, which does the mapping. The map function must be stateless and non-interfering. Since a new stream is returned, map( ) is an intermediate method.
Function is a functional interface declared in java.util.function. It is declared as shown here:
Function<T, R>
As it relates to map( ), T is the element type and R is the result of the mapping. Function has the abstract method shown here:
R apply(T val)
Here, val is a reference to the object being mapped. The mapped result is returned. The following is a simple example of map( ). It provides a variation on the previous
example program. As before, the program computes the product of the square roots of the values in an ArrayList. In this version, however, the square roots of the elements are first mapped to a new stream. Then, reduce( ) is employed to compute the product.
// Map one stream to another.
import java.util.*;
import java.util.stream.*;
class StreamDemo4 {
public static void main(String[] args) {
// A list of double values.
ArrayList<Double> myList = new ArrayList<>( );
myList.add(7.0);
myList.add(18.0);
myList.add(10.0);
myList.add(24.0);
myList.add(17.0);
myList.add(5.0);
// Map the square root of the elements in myList to a new stream.
Stream<Double> sqrtRootStrm = myList.stream().map((a) -> Math.sqrt(a));
// Find the product of the square roots.
double productOfSqrRoots = sqrtRootStrm.reduce(1.0, (a,b) -> a*b);
System.out.println("Product of square roots is " + productOfSqrRoots);
}
}
The output is the same as before. The difference between this version and the previous is simply that the transformation (i.e., the computation of the square roots) occurs during mapping, rather than during the reduction. Because of this, it is possible to use the two-parameter form of reduce( ) to compute the product because it is no longer necessary to provide a separate combiner function.
Here is an example that uses map( ) to create a new stream that contains only selected fields from the original stream. In this case, the original stream contains objects of type NamePhoneEmail, which contains names, phone numbers, and e-mail addresses. The program then maps only the names and phone numbers to a new stream of NamePhone objects. The e-mail addresses are discarded.
//Use map() to create a new stream that contains only
//selected aspects of the original stream.
import java.util.*;
import java.util.stream.*;
class NamePhoneEmail { String name;
String phonenum; String email;
NamePhoneEmail(String n, String p, String e) { name = n;
phonenum = p; email = e;
}
}
class NamePhone { String name; String phonenum;
NamePhone(String n, String p) { name = n;
phonenum = p;
}
}
class StreamDemo5 {
public static void main(String[] args) {
// A list of names, phone numbers, and e-mail addresses.
ArrayList<NamePhoneEmail> myList = new ArrayList<>( );
myList.add(new NamePhoneEmail("Larry", "555-5555", "[email protected]"));
myList.add(new NamePhoneEmail("James", "555-4444", "[email protected]"));
myList.add(new NamePhoneEmail("Mary", "555-3333", "[email protected]"));
System.out.println("Original values in myList: "); myList.stream().forEach( (a) -> {
System.out.println(a.name + " " + a.phonenum + " " + a.email); });
System.out.println();
// Map just the names and phone numbers to a new stream.
Stream<NamePhone> nameAndPhone = myList.stream().map(
(a) -> new NamePhone(a.name,a.phonenum) );
System.out.println("List of names and phone numbers: "); nameAndPhone.forEach( (a) -> {
System.out.println(a.name + " " + a.phonenum); });
}
}
The output, shown here, verifies the mapping:
Original values in myList:
Larry 555-5555 [email protected]
James 555-4444 [email protected]
Mary 555-3333 [email protected]
List of names and phone numbers:
Larry 555-5555
James 555-4444
Mary 555-3333
Because you can pipeline more than one intermediate operation together, you can easily create very powerful actions. For example, the following statement uses filter( ) and then map( ) to produce a new stream that contains only the name and phone number of the elements with the name "James":
Stream<NamePhone> nameAndPhone = myList.stream().
filter((a) -> a.name.equals("James")). map((a) -> new NamePhone(a.name,a.phonenum));
This type of filter operation is very common when creating database-style queries. As you gain experience with the stream API, you will find that such chains of operations can be used to create very sophisticated queries, merges, and selections on a data stream.
In addition to the version just described, three other versions of map( ) are provided. They return a primitive stream, as shown here:
IntStream mapToInt(ToIntFunction<? super T> mapFunc) LongStream mapToLong(ToLongFunction<? super T> mapFunc) DoubleStream mapToDouble(ToDoubleFunction<? super T> mapFunc)
Each mapFunc must implement the abstract method defined by the specified interface, returning a value of the indicated type. For example, ToDoubleFunction specifies the applyAsDouble(T val ) method, which must return the value of its parameter as a double.
Here is an example that uses a primitive stream. It first creates an ArrayList of Double values. It then uses stream( ) followed by mapToInt( ) to create an IntStream that contains the ceiling of each value.
// Map a Stream to an IntStream.
import java.util.*;
import java.util.stream.*;
class StreamDemo6 {
public static void main(String[] args) {
// A list of double values.
ArrayList<Double> myList = new ArrayList<>( );
myList.add(1.1);
myList.add(3.6);
myList.add(9.2);
myList.add(4.7);
myList.add(12.1);
myList.add(5.0);
System.out.print("Original values in myList: "); myList.stream().forEach( (a) -> {
System.out.print(a + " "); });
System.out.println();
// Map the ceiling of the elements in myList to an IntStream.
IntStream cStrm = myList.stream().mapToInt((a) -> (int) Math.ceil(a));
System.out.print("The ceilings of the values in myList: "); cStrm.forEach( (a) -> {
System.out.print(a + " "); });
}
The output is shown here:
Original values in myList: 1.1 3.6 9.2 4.7 12.1 5.0
The ceilings of the values in myList: 2 4 10 5 13 5
The stream produced by mapToInt( ) contains the ceiling values of the original elements in myList.
Before leaving the topic of mapping, it is necessary to point out that the stream API also provides methods that support flat maps. These are flatMap( ), flatMapToInt( ), flatMapToLong( ), and flatMapToDouble( ). The flat map methods are designed to handle situations in which each element in the original stream is mapped to more than one element in the resulting stream.
Related Topics
Copyright © 2018-2020 BrainKart.com; All Rights Reserved. Developed by Therithal info, Chennai. | https://www.brainkart.com/article/Mapping---Java-Stream-API_10694/ | CC-MAIN-2019-47 | en | refinedweb |
12.4.2. Develop a JAX-WS Client Application
Service
- Overview
- A
Serviceis an abstraction which represents a WSDL service. A WSDL service is a collection of related ports, each of which includes a port type bound to a particular protocol and a particular endpoint address.Usually, the Service is generated when the rest of the component stubs are generated from an existing WSDL contract. The WSDL contract is available via the WSDL URL of the deployed endpoint, or can be created from the endpoint source using the
wsprovide.shcommand in the
EAP_HOME/bin/directory.This type of usage is referred to as the static use case. In this case, you create instances of the
Serviceclass which is created as one of the component stubs.You can also create the service manually, using the
Service.createmethod. This is referred to as the dynamic use case.
- Usage
- Static Use Case
- The static use case for a JAX-WS client assumes that you already have a WSDL contract. This may be generated by an external tool or generated by using the correct JAX-WS annotations when you create your JAX-WS endpoint.To generate your component stubs, you use the
wsconsume.shor
wsconsume.batscript which is included in
EAP_HOME/bin/. The script takes the WSDL URL or file as a parameter, and generates multiple of files, structured in a directory tree. The source and class files representing your
Serviceare named
CLASSNAME_Service.javaand
CLASSNAME_Service.class, respectively.The generated implementation class has two public constructors, one with no arguments and one with two arguments. The two arguments represent the WSDL location (a
java.net.URL) and the service name (a
javax.xml.namespace.QName) respectively.The no-argument constructor is the one used most often. In this case the WSDL location and service name are those found in the WSDL. These are set implicitly from the
@WebServiceClientannotation that decorates the generated class.
Example 12.19. Example); } ... }
- Dynamic Use Case
- In the dynamic case, no stubs are generated automatically. Instead, a web service client uses the
Service.createmethod to create
Serviceinstances. The following code fragment illustrates this process.
Example 12.20. Creating Services Manually
URL wsdlLocation = new URL(""); QName serviceName = new QName("", "MyService"); Service service = Service.create(wsdlLocation, serviceName);
- Handler Resolver
- JAX-WS provides a flexible plug-in framework for message processing modules, known as handlers. These handlers extend the capabilities of a JAX-WS runtime system. A
Serviceinstance provides access to a
HandlerResolvervia a pair of
getHandlerResolverand
setHandlerResolvermethods that can configure a set of handlers on a per-service, per-port or per-protocol binding basis.When a
Serviceinstance creates a proxy or a
Dispatchinstance, the handler resolver currently registered with the service creates the required handler chain. Subsequent changes to the handler resolver configured for a
Serviceinstance do not affect the handlers on previously created proxies or
Dispatchinstances.
- Executor
Serviceinstances can be configured with a
java.util.concurrent.Executor. The
Executorinvokes any asynchronous callbacks requested by the application. The
setExecutorand
getExecutormethods of
Servicecan modify and retrieve the
Executorconfigured for a service.
A dynamic proxy is an instance of a client proxy using one of the
getPort methods provided in the
Service. The
portName specifies the name of the WSDL port the service uses. The
serviceEndpointInterface specifies the service endpoint interface supported by the created dynamic proxy instance.
Example 12.21.
getPort Methods
public <T> T getPort(QName portName, Class<T> serviceEndpointInterface) public <T> T getPort(Class>T< serviceEndpointInterface)
wsconsume.shcommand, which parses the WSDL and creates Java classes from it.
Example 12.22. Returning the Port of a Service
declares a reference to a Web Service. It follows the resource pattern shown by the
javax.annotation.Resource annotation defined in.
Use Cases for
@WebServiceRef
- You can use it to define a reference whose type is a generated
Serviceclass. In this case, the type and value element each refer to the generated
Serviceclass type. Moreover, if the reference type can be inferred by the field or method declaration the annotation is applied to, the type and value elements may (but are not required to) have the default value of
Object.class. If the type cannot be inferred, then at least the type element must be present with a non-default value.
- You can use it to define a reference whose type is an SEI. In this case, the type element may (but is not required to) be present with its default value if the type of the reference can be inferred from the annotated field or method declaration. However, the value element must always be present and refer to a generated service class type, which is a subtype of
javax.xml.ws.Service. The
wsdlLocationelement, if present, overrides the WSDL location information specified in the
@WebServiceannotation of the referenced generated service class.
Example 12.23.
@WebServiceRefExamples
public class EJB3Client implements EJB3Remote { @WebServiceRef public TestEndpointService service4; @WebServiceRef public TestEndpoint port3;
XML Web Services use XML messages for communication between the endpoint, which is deployed in the Java EE container, and any clients. The XML messages use an XML language called Simple Object Access Protocol (SOAP). The JAX-WS API provides the mechanisms for the endpoint and clients to each be able to send and receive SOAP messages and convert SOAP messages into Java, and vice versa. This is called
marshalling and
unmarshalling.
Dispatchclass provides this functionality.
Dispatchoperates in one of two usage modes, which are identified by one of the following constants.
javax.xml.ws.Service.Mode.MESSAGE- This mode directs client applications to work directly with protocol-specific message structures. When used with a SOAP protocol binding, a client application works directly with a SOAP message.
javax.xml.ws.Service.Mode.PAYLOAD- This mode causes the client to work with the payload itself. For instance, if it is used with a SOAP protocol binding, a client application would work with the contents of the SOAP body rather than the entire SOAP message.
Dispatchis a low-level API which requires clients to structure messages or payloads as XML, with strict adherence to the standards of the individual protocol and a detailed knowledge of message or payload structure.
Dispatchis a generic class which supports input and output of messages or message payloads of any type.
Example 12.24.
Dispatch Usage which clients can use. It is implemented by proxies and is extended by the
Dispatch interface.
BindingProviderinstances may provide asynchronous operation capabilities.Asynchronous operation invocations are decoupled from the
BindingProviderinstance at invocation time. The response context is not updated when the operation completes. Instead, a separate response context is made available using the
Responseinterface.
Example 12.25. Example Asynchronous InvocationInvocations
The
@Oneway annotation indicates that the given web method takes an input message but returns no output message. Usually, a
@Oneway method returns the thread of control to the calling application before the business method is executed.
Example 12.26. Example
@Oneway Invocation
@WebService (name="PingEndpoint") @SOAPBinding(style = SOAPBinding.Style.RPC) public class PingEndpointImpl { private static String feedback; @WebMethod @Oneway public void ping() { log.info("ping"); feedback = "ok"; } @WebMethod public String feedback() { log.info("feedback"); return feedback; } }.
Example 12.27. JAX-WS Timeout Configuration. | https://access.redhat.com/documentation/en-us/jboss_enterprise_application_platform/6/html/development_guide/develop_a_jax-ws_client_application | CC-MAIN-2019-47 | en | refinedweb |
sem_timedwait(), sem_timedwait_monotonic()
Wait on a named or unnamed semaphore, with a timeout
Synopsis:
#include <semaphore.h> #include <time.h> int sem_timedwait( sem_t * sem, const struct timespec * abs_timeout ); int sem_timedwait_monotonic( sem_t * sem, const struct timespec * abs_timeout );
Arguments:
- sem
- The semaphore that you want to wait on.
- abs_timeout
- A pointer to a timespec structure that specifies the maximum time to wait to lock the semaphore, expressed as an absolute time.
Library:
libc
Use the -l c option to qcc to link against this library. This library is usually included automatically.
Description:
The sem_timedwait() function locks the semaphore referenced by sem as in the sem_wait() function. However, if the semaphore can't be locked without waiting for another process or thread to unlock the semaphore by calling sem_post() , the wait is terminated when the specified timeout expires. The timeout is based on the CLOCK_REALTIME clock.
The sem_timedwait_monotonic() function is a QNX Neutrino extension; it's similar to sem_timedwait(), but it uses CLOCK_MONOTONIC, so the timeout isn't affected by changes to the system time..
Returns:
- 0
- The calling process successfully performed the semaphore lock operation on the semaphore designated by sem.
- -1
- The call was unsuccessful (errno is set). The state of the semaphore is unchanged.
Errors:
- EDEADLK
- A deadlock condition was detected.
- EINTR
- A signal interrupted this function.
- EINVAL
- Invalid semaphore sem, or the thread would have blocked, and the abs_timeout parameter specified a nanoseconds field value less than zero or greater than or equal to 1000 million.
- ETIMEDOUT
- The semaphore couldn't be locked before the specified timeout expired.
Examples:
#include <stdio.h> #include <semaphore.h> #include <time.h> main(){ struct timespec tm; sem_t sem; int i=0; sem_init( &sem, 0, 0); do { clock_gettime(CLOCK_REALTIME, &tm); tm.tv_sec += 1; i++; printf("i=%d\n",i); if (i==10) { sem_post(&sem); } } while ( sem_timedwait( &sem, &tm ) == -1 ); printf("Semaphore acquired after %d timeouts\n", i); return; }
Classification:
sem_timedwait() is POSIX 1003.1 SEM TMO; sem_timedwait_monotonic() is QNX Neutrino | https://developer.blackberry.com/playbook/native/reference/com.qnx.doc.neutrino.lib_ref/topic/s/sem_timedwait.html | CC-MAIN-2019-47 | en | refinedweb |
Titanium TurboTitanium Turbo
Turbo is not an official Axway product. It is an open-source project that is supported exclusively by the Titanium development community.
📝 Description
Titanium Turbo is a variation of
Titanium Alloy that adds some enhancements and customizations for rapid development.
This version of Titanium Turbo is based on
Titanium Alloy 1.14.1
🚀 Getting Started
- Create new Titanium Alloy project
- Install
Titanium Turboin root of project
npm install --save-dev @titanium/turbo
- Install
Titanium Turbo Pluginin root of project
npm install --save-dev @titanium/plugin-turbo
- Build or Run app as you would normally.
✨Features
See
changelog.mdfor history of changes
- Supports installing npm packages in root of project for use in mobile [TIMOB-26352]
- Support for the following XML attributes in
textField,
label, and
textArea: [ALOY-1547]
- fontSize
- fontFamily
- fontStyle
- fontWeight
- textStyle
- Replaced Underscore.js with Lodash 4.17.12 [ALOY-1168]
- Updated babel.js to 7.x [ALOY-1629]
- Enhanced support for babel config files:
.babelrc,
.babelrc.jsand
babel.config.js
- Added support for
camelCase,
snake_case, and
kabab-casein XML views. [ALOY-1647]
- Added plugin property
compileConfig.dir.resourcesAlloy
- Updated moment to 2.24.0 [ALOY-1682]
- Added backbone 1.4.0 [ALOY-1648]
- Made default backbone version: 1.4.0
- Added support for xml namespaced attributes per platform (e.g.
ios:textor
android:text) [ALOY-1646]
- Added support for xml attributes with dotted notation (e.g.
font.fontSize) [ALOY-1363]
- Added support for using
$.argsin XML views. [ALOY-1316]
- Added support for using
$.*in XML views. -- Anything that starts with "$." in an Alloy XML View will be used literally and not treated as a string.
- Added support for using
turbo.*in XML views. -- Anything that starts with "turbo." in an Alloy XML View will be used literally and not treated as a string. [Required workaround for
node_modulessupport to LiveView] [TIMOB-27206]
- Added support for
__init()function in controller that will be called before view is built. -- Allows
$.*variables to be created and used in XML views.
- Added support for
visibilityproperty in XML Views with possible values of:
hidden,
collapse, and
visible-- Allows collapsing of view in XML. [TIMOB-27307]
- Added constants:
Ti.UI.VISIBILITY_COLLAPSE,
Ti.UI.VISIBILITY_HIDDEN, and
Ti.UI.VISIBILITY_VISIBLE
- Added support for
modelNameXML attribute to be used with with
dataCollectionto assign variable name to current model [Defaults to
__currentModel]
- Added support for
dataNameXML attribute to be used with with
dataCollectionto assign variable name to
model.__transform[Defaults to
$model] -- Allows developer to reference current model properties like
$model.myproperty
- Added support for adding code to XML View attributes when surrounded by '~' [ALOY-1699]
- Added support for
Codeelement in XML View. Add code by body or
srcattribute. [ALOY-1700]
- Added value alias
centerfor
Ti.UI.TEXT_VERTICAL_ALIGNMENT_CENTERwhen used with
verticalAlignXML attribute [ALOY-1703]
- Added property alias
textfor
Ti.UI.Button.titlewhen used as XML attribute
- Added property alias
srcfor
Ti.UI.ImageView.imagewhen used as XML attribute
- Added support for using underscore (instead of lodash) with this tiapp.xml property:
<property name="use-underscore"type="bool">true</property>
🔗 Related Links
- Geek Mobile Toolkit - Toolkit for creating, building, and managing mobile app projects.
- Titanium Turbo Template (Default) - Template for default Turbo app. Based on the basic Alloy Template + some extra goodies.
- Titanium Turbo Template (Next) - Template for Turbo app (with extras). Based on the default Turbo Template + some extras.
- Titanium Mobile - Open-source tool for building powerful, cross-platform native apps with JavaScript.
- Alloy - MVC framework built on top of Titanium Mobile.
- Appcelerator - Installer for the Appcelerator Platform tool
📚Learn More
📣 Feedback
Have an idea or a comment? Join in the conversation here!
©️. | https://libraries.io/npm/@titanium%2Fturbo | CC-MAIN-2019-47 | en | refinedweb |
hu_AuthEncDecryptEnd()
Destroys an authenticated encryption context object, and verifies the MAC.
Synopsis:
#include "huauthenc.h"
int hu_AuthEncDecryptEnd(sb_Context *authEncCtx, size_t macLen, const decryption operation. An authenticate encryption context must be destroyed before the corresponding symmetric key object and symmetric key parameters object are destroyed. The MAC supplied will be verified.
Returns:
- SB_ERR_BAD_CONTEXT
The authEncCtx is of the wrong type.
- SB_ERR_NULL_INPUT_BUF_LEN
The macLen parameter does not match the length specified in the hu_AuthEncBegin function.
- SB_ERR_NULL_INPUT_BUF
The mac buffer is unexpectedly NULL.
- SB_ERR_MAC_INVALID
The value of mac is invalid
Last modified: 2014-05-14
Got questions about leaving a comment? Get answers from our Disqus FAQ.comments powered by Disqus | https://developer.blackberry.com/native/reference/core/com.qnx.doc.crypto.lib_ref/topic/hu_AuthEncDecryptEnd.html | CC-MAIN-2019-47 | en | refinedweb |
CUPS IPP print to Novell servers error since 11.10 upgrade
Bug Description
We have multiple reports of printing errors around our campus since upgrading to 11.10. The error message is: 'cups-ipp-
Our advised setup for Ubuntu users has been to print to queues on a Novell server via IPP. This worked fine and without error in previous ubuntu versions. The problem appears to be the addition of a compliance test between CUPS 1.4.6 and 1.5.0 (/backend/ipp.c revs 9490 9759). The validation fails to non-CUPS IPP servers since Validate-Job is a CUPS extension to IPP.
$ apt-cache policy cups
cups:
Installed: 1.5.0-8ubuntu3
Candidate: 1.5.0-8ubuntu3
Version table:
*** 1.5.0-8ubuntu3 0
500 http://
100 /var/lib/
1.5.0-8 0
500 http://
Can you provide a simple patch which works around the bug? We could solve the problem for Oneiric then.
Independent of this, can you post a bug to CUPS upstream on
http://
Thanks.
I've got excatly the same problem with a HP PSC 1510 which however is absolutely recognized.
It's possible to print when it's directly connected to the PC.
On the other hand, when it's connected on the network using my LiveBox2 I get the message "cups-ipp-
I'd like to indicate I'm not alone as this can show it
http://
Hi,
Like GALLINARI, I confirm this bug under 11.10 with a Canon Pixma iP4500 connected by USB to a Livebox2 (modem router ADSL). Under 10.10 and 11.04 there wasn't any problem : I could print using IPP. But since I upgraded to 11.10 it's impossible. I can print if I connect directly my printer to my laptop via USB.
Quick update:
The bug is now filed upstream as requested (http://
(I should also apologise at this point, since on re-reading http://
OK, as a quick fix, I have effectively replaced backend/ipp.c with the 1.4.x version (branches/
-------
--- ipp-1.4x.c 2011-10-27 16:50:04.000000000 +0100
+++ ipp.c 2011-10-27 16:37:46.000000000 +0100
@@ -428,7 +428,7 @@
if ((fd = cupsTempFd(
{
- _cupsLangPrintE
+ _cupsLangPrintE
return (CUPS_BACKEND_
}
-------
I would not trust this without a lot more testing, but this worked for me just now.
Thank you very much Robert,
Your patch works fine for me : now I can print like under 10.10 and 11.04.
Besides I learned how patching : I had never made this before
For those who would try this you can download the source of cups here : http://
It's easier to use "apt-get source cups" to fetch the source code, since then you get the latest source code with the Ubuntu/Debian patches applied too. The orig.tar.bz2 file is actually the unaltered CUPS source.
At the risk of being slightly off-topic, these instructions should work for building and replacing the ipp backend manually:
* Download the patch file in my previous comment.
*.
* Run "./configure"
Normally you would do "make && sudo make install", compiling the entirety of CUPS (you'll need the po4a package installed first). We have CUPS installed already though, so to save time we can just compile the contents of the "backend" directory on their own:
* "cd backend && make"
* Run these next two commands to back up the existing ipp backend file and replace it with the new one:
- "sudo cp /usr/lib/
- "sudo cp ./ipp /usr/lib/
Thanks for yours intructions in order to patch correctly.
For me you aren't at all off-topic : I had to find myself how to patch and there aren't much informations that explain how to make it properly.
So I'm going to translate in french yours advices to help others users.
Regards
Setting to "Confirmed" as a working solution is presented here. Not yet "Triaged" as it needs to be discussed whether this solution should really get applied. Downgrading the backend from 1.5.0 to 1.4.x is a rather big patch and probably pulls out many features, not only the feature which caused the regression. What we need, especially for an SRU in Oneiric, is to really find out what caused the regression and pull out only that feature or better fix it.
For those who want explanations in french, you can find them here : http://
Another update:
First, for the instructions I posted yesterday, you do in fact need to build the whole of CUPS for them to work.
Secondly, I did a bit of digging through Wireshark dumps last night, and found out that the Validate-Job calls were not the whole story. It turns out that CUPS 1.5 adds a document-format attribute to its print jobs. It appears to dig through the server response for supported types, and if it does not match a MIME type to that of the document, it assumed "application/
The patch attached here replaces that assumed value with NULL, which results in the attribute being skipped. This replicates the 1.4 behaviour, although we still get the complaints over IPP compliance. I also added a bit of debug-level logging around the document-format discovery area of the code.
ThierryM: would you be willing to try this new version and see if it prints for you?
Robert, does applying only the patch attached to your comment #12 fix the problem? It is a simple small patch which we could easily make available to our users as a Stable Release Update (SRU) for Oneiric. If additional patches are needed, please tell me the minimum set of patches needed to solve the problem. Thanks in advance.
Till: yes, applying just the patch from comment 12 fixes the problem for me. I do not feel that any additional patches are needed, simply because the new patch behaves in the same way as the code from 1.4.6, and that appears to work fine for everyone. So, if the comment #12 patch also works for ThierryM, I would suggest using that patch as-is.
The missing-
Robert, thank you very much.
ThierryM, can you please apply Robert's patch from comment #12 to the original Ubuntu package of CUPS, and no other patches. Can you test whether only this change is enough in Oneiric's CUPS to solve your problem? Thanks in advance.
The attachment "Patch: replaces backend/ipp.c with the 1.4.x version (branches/
[This is an automated message performed by a Launchpad user owned by Brian Murray. Please contact him regarding any issues with the action taken in this bug report.]
Hi,
I tested the patch #12 alone (I desinstalled CUPS, downloaded the source package, I patched with the patch #12) and it doesn't solve my problem : the bug seems the same.
Thierry,
I would be interested in seeing what CUPS is sending to the print server. Would you be willing to submit a debug log and the results of "tcpdump -i eth0 -p port 631 > packetlog" showing an attempt at printing the Ubuntu test page?
Thanks in advance,
Robert
Better make that "sudo tcpdump -i eth0 -p -w packetlog port 631" (or alternatively, use Wireshark with capture filter "port 631").
One final point: if you are happy to collect the IPP packets, it would be very useful if I looked at logs/packet dumps for both the new (broken) patch, and the previous one which worked for you. That way, I ought to be able to see just what is different between the two versions! Either emailing them to me or attaching them is fine from my point of view.
Hi Robert,
Like I print from my laptop via wifi I did : "sudo tcpdump -i wlan0 -p -w packetlog port 631". I hope I did right.
I join the packetlog.
The previous "packetlog" was obtained with the first patch that's working. Do you want an other packetlog with the broken patch ?
Hi Thierry,
Yes, please! :)
So, there's the packetlog2 with the broken patch.
Hi Thierry,
Thanks for the packet logs - they were very interesting! It looks to me as if CUPS is continually trying to talk to your print server using IPP/2.0, which it does not appear to support. With the present code, CUPS expects it to return an error of IPP_VERSION_
Would you mind applying the following inline patch to the existing version from comment #12 and seeing if that helps?
=== modified file 'backend/ipp.c'
--- old/backend/ipp.c 2011-10-28 09:12:41 +0000
+++ new/backend/ipp.c 2011-10-29 00:11:43 +0000
@@ -247,6 +247,7 @@
ppd_file_t *ppd; /* PPD file */
_ppd_cache_t *pc; /* PPD cache and mapping data */
fd_set input; /* Input set for select() */
+ int server_ipp_version;
/*
@@ -830,6 +831,18 @@
supported = cupsDoRequest(http, request, resource);
ipp_status = cupsLastError();
+
+ /* Extract server IPP version, and use this to downgrade */
+ server_ipp_version = supported-
+ server_ipp_version += supported-
+ if (version > server_ipp_version)
+ {
+ fprintf(stderr, "INFO: Server responded to our IPP/%d.%d request ",
+ version / 10, version % 10);
+ fprintf(stderr, "with an IPP/%d.%d response - downgrading!\n",
+ server_ipp_version / 10, server_ipp_version % 10);
+ version = server_ipp_version;
+ }
fprintf(
Actually, before testing the patch in my previous comment, try changing your printer URI to "ipp://
I also think it might be worth me repositioning the code within that patch so that it is only called if the existing downgrade code finds nothing wrong. (Otherwise, we may end up downgrading further than we have to.)
Hi Robert,
I have applied the last patch over CUPS yet patched with the patch in the message #6 but the problem still exists : thre's no amelioration.
I join the packetlog3 to look it.
Sorry but I posted my previous message without reading the message #27.
But when I use "ipp://
Sorry again but in my message #28 it's not the patch in message #6 : I made a mistake when I wrote, I used CUPS patched with the patch in the message #12 to do the test.
Thierry,
The packetlog3 file was interesting because it looks like it's downgrading to IPP/1.0 fine now! So, time for me to figure out why you're getting HTTP 400 (Bad Request) errors from it...
This looks like it is a separate bug from the original bug reported here, which comment #12 seems to fix well enough. Perhaps we should get this split out into its own bug report and continue working on this there?
Robert,
For me, I'm not capable to distinct that there is 2 différents bugs :-) : so do what you think fair or more efficient. If you split, could you indicate the new number of the bug ?
Thank you for your job because now with the first patch I can again print through the network.
Regards
Thanks for your patience with this, Thierry, it's much appreciated! I'll leave the bug splitting decision to Till, I think. In the meantime, I have another full patch to try. This one is inspired by the fact that the old version never tried to use the "Expects: 100-continue" header - instead, it just sent the whole file straight away. You get a new IPP option "nohttpcontinue
Robert, I think a second bug report is not needed. As soon as you have solved the problem with Thierry, I will apply the complete set of patches (and also forward it upstream).
I patched the original CUPS with the last cumulative patch but it doesn't work.
Here the log package4.
Is that with or without the nohttpcontinue option (URI ipp://192.
With the 2 URI "ipp://
Thanks - now it's time for me to figure out why nothing changed!
Hi, I'm using Kubuntu 11.10 and I have the same issue with a
U.S. Robotics Wireless MAXg ADSL Gateway
with a HP Laserjet 6L connected through the usb connection (using a paraller to USB connector)
The patch at #12 worked for me and just to recap I followed the following steps:
* install with synaptic or other package manager "po4a"
*.
* Download the patch file in comment #12
* Run "./configure"
* Run "make"
* Run these next two commands to back up the existing ipp backend file and replace it with the new one:
- "sudo cp /usr/lib/
- "sudo cp ./ipp /usr/lib/
Thanks all for the help on this!
Note: if I try to install the patched version on its own the KDE printing doesn't work.
Sorry, I try again:
* install with synaptic or other package manager "po4a"
* Run "mkdir cups && cd cups && apt-get source cups" to fetch Ubuntu's source code for CUPS and place it in its own directory.
* Change to the "cups-1.5.0" directory,
* Download the patch file in comment #12
* Run "patch -p1 < ipp-patch-file", where ipp-patch-file is the location of the patch file.
* Run "./configure"
* Run "make"
* Run these next two commands to back up the existing ipp backend file and replace it with the new one:
- "sudo cp /usr/lib/
- "sudo cp ./ipp /usr/lib/
The latest update on the upstream bug is that it is the Novell (and Livebox2) servers at fault, and not CUPS. The bug has been "Closed w/o Resolution". I have no idea where this leaves us long-term - presumably trying to write our own patch to successfully disable chunking (fixing the Livebox2 issue?), and using the existing patch from #12 to work around the Novell issue.
Hi Robert,
Thanks for your information. But I don't understand why the Livebox2 worked fine before with the older CUPS ? And why the Livebox2 works under Windows ?
I regret my upgrade to Oneiric : Maverick 10.10 worked much better for printer (USB detection doesn't work too for my printers MP240 and iP4500).
Other solution, It's possible to downgrade CUPS ?
Anyway thank you for your patch very usefull.
Regards
I've not tried it, but Windows probably works fine because it avoids HTTP chunked transfers, like CUPS 1.4 does.
I've no idea if it would work or not, but you could try removing the CUPS packages, and then playing with apt pinning to force those to be reinstalled from the Lucid repositories. I have no idea if that would work well, and it's not an ideal solution in any case, but may be the only option.
I have the following server:
U.S. Robotics Wireless MAXg ADSL Gateway
So, it sounds strange that Novell, Livebox 2 and MAXg are faulty, after CUPS update.
Also in my case, Windows XP, Windows 7 and Kubuntu 11.04 worked totally fine with the same configuration...
OK, I think I might finally have this HTTP chunking issue sorted, at least partially. In the case where only one job is sent at one (so IPP's Print-Job is used instead of Create-Job), the attached patch prevents the use of HTTP chunking for me.
This needs to be enabled by setting your printer URI to "ipp://
Notes:
1. I still get the Expect: 100-continue header for some reason, regardless of my attempts to disable it, so I gave up there.
2. The Novell servers I have access to work regardless - they only require the document-format patch in comment 12.
As it turned out, whilst the previous patch works, there was one issue: part of the data stream from the printer driver was lost! This only occurs when using the Content-Length fallback code, which I force on with the previous patch.
Gory details:
For the fallback, the IPP backend copies the data to a temporary file, and fetches the file size (using backendRunLoop). Unfortunately, earlier on in the code, it reads from stdin to a buffer, which is forgotten about in the fallback case! The end result was corruption of printouts using PCL drivers.
I have now added yet another fix to the IPP backend to write this initial data out to the temporary file and update the length accordingly. This version now prints correctly, as confirmed with hard copy.
ThierryM and others with Livebox2 routers: could you please check that this prints when nohttpchunking is enabled as above?
Hi,
I also experiment the same issue since I updated to Oneiric. My ADSL/modem "BBox2" router is branded by another french provider "Bouygues", but it's in fact the same device : SAGEM f@st 3504.
I'll try you patch and give you some news.
Thxs for all
Great : using patch of comment #46, it works for me but with two visible non-fatal errors :
cups-ipp-
spool-area-full
Notice that I had to create a "new" printer using the new URI "ipp://
I apologize, but I didn't succeed in looging a tcpdump, i got only empty files (after changing the network device).
Mavosaure, thanks for testing the patch for me. There is no need to worry about the tcpdumps, given it worked as expected, but don't let that stop you! It may help me with the two messages you saw, which I am a little surprised by. You can try clearing out /var/spool/cups to see if that sorts out the "spool area full" message (but I expect this is server-side). The missing-job-history message is most likely another cosmetic complaint about IPP specification compliance. It can also apparently occur if the job disappears from the print server. It seems to be working though, which is better than last week!
Hi,
I tried the last patch #46 and it's working but I have first this message : "spool-area-full" before the printing succeed.
The URI printer is "ipp://
I join the result of the command "tcpdump -i wlan0 -p -w packetlog5 port 631".
Regards
Hi all,
This is just a guess, but one thing you could try is setting the IPP version. The patch here removes my auto-downgrade code, so you should be able to test using the following URIs:
ipp://192.
ipp://192.
ipp://192.
I don't know if this will fix this spool-area-full message, but it can't hurt trying it. Version 1.1 ought to match CUPS 1.4.6.
Thanks again for your patience everyone!
I patched directly with the minus auto-downgrade. I obtain the same results with the 3 URIs.
But I noticed (and perhaps with the patch #46 too) that I can print the first page diretly but after I had to push the button on the printer to feed paper in order to print.
I have always the "spoll-area-full" message and an other (until I push the button) that says "copying print data".
The "Copying print data" message is safe enough - that's generated when the fallback code copies the print job to disk. The spool-area-full part seems to be the server's fault, and appears during the processing stage (we seem to get multiple connections too). Your CUPS 1.4.6 logs don't show any requests for printer state during printing, which might explain why it's started appearing now!
What's interesting here is that this pausing behaviour sounds very similar to this bug:
https:/
Could we be hitting this same bug somehow? With misleading status messages, it's entirely possible...
Since my uni uses Novell infrastructure, I tried Robert's patch from comment #12, and that seems to solve the problem for me. Tim, or anyone else affected,
Accepted cups into oneiric-proposed, the package will build now and be available in a few hours. Please test and give feedback here. See https:/
For me it's OK : applying the package-update cups - 1.5.0-13 (from the
proposed repository) make my printer work again.
Good job!
Thanks!
Le 05/12/2011 07:15, Martin Pitt a écrit :
> Hello Tim, or anyone else affected,
>
> Accepted cups into oneiric-proposed, the package will build now and be
> available in a few hours. Please test and give feedback here. See
> https:/
> enable and use -proposed. Thank you in advance!
>
> ** Tags added: verification-needed
>
mavosaure, thank you very much for testing. Marking the bug as verified.
Hi,
I tested the new package-update of cups for my Canon MP240 plugged on a Linksys Switch Print Server PSUS4. And it works perfectly : until now, I hadn't succeeded to print with any earlier version of Ubuntu (the first page stayed blocked).
So for me, now it's an improvement (no more regression like until now).
I'm going to test at home with my Livebox and my Canon iP4500 and I tell you if it works too.
I have filed three new bugs upstream now for these issues. This is deliberate since I know upstream are reluctant to work around every possible print server bug from last time.
http://
This is the original bug regarding Novell print servers, and the patch is the same as in comment #12 here.
http://
This covers the remainder of the patches here, and attempts to sort out the Livebox2 issues. As disabling chunking is seen as a large change to work around one printer server's bugs, this is unlikely to be accepted upstream unfortunately. Does anyone know if OS X Lion compatibility has been filed as an issue with Orange France or Sagem?
http://
This is the bug where print data can be lost if the print server does not support HTTP 1.1 (fixed in comment #46 here). I separated this bug out since this is a true (if rarely triggered) bug in upstream, as opposed to a workaround for print server bugs. This may well get fixed, but will achieve nothing for Livebox2 users without the chunking patches being included too.
Hi,
I tested the new package-update of cups with my Canon Pixma iP4500 plugged on the Livebox2 router. And now, I can print via wifi like before under Ubuntu 10.10 .
So for me, the bug is fixed.
I thank everybody especially Robert Bradley for this patience and perseverance.
Regards
Thierry, also thank you for doing all the testing and supplying all the information for working on this bug.
This bug was fixed in the package cups - 1.5.0-8ubuntu6
---------------
cups (1.5.0-8ubuntu6) oneiric-proposed; urgency=low
*/
-- Till Kamppeter <email address hidden> Tue, 29 Nov 2011 21:49:41 +0100
I had the same problem on suse 12.1.
I installed cups 1.5.2 but tht did not resolved the problem.
I was using a livebox with ipp://192.
printfile was not accepted.
I expected that the new cups version take into account the patch. Must i wait for another cups update ?
many thanks
Moreau, please report your problem at SUSE then.
Yes already done, they sent me to cups, i want to mentioned that apparently CUPS 1.5.2 did not incorporate the patch discussed here.
Thanks for your remark
I collected this report on cups.org :
http://
I am not sure to clearly understand, but does that mean that they wont take into account that problem ?
Many thanks for your advices
SM
I have attached an example CUPS log to this comment to demonstrate the problem.
Looking at the source more closely, it appears that the initial test for Validate-Job succeeds, but actually using it before printing fails. One very quick way to test this would be to find the line "while(
!job_canceled && validate_job)" (1229 upstream), and simply put "validate_job = 0" on the line above this. That should skip the attempt to use Validate-Job. Longer term, this might have to become a configurable option, either globally or per IPP printer. | https://bugs.launchpad.net/ubuntu/+source/cups/+bug/881843 | CC-MAIN-2019-47 | en | refinedweb |
Opened 8 years ago
Closed 8 years ago
#11324 closed (invalid)
Tutorial 1 - import datetime
Description
Where do I put this custom method:
class Poll(models.Model):
# ...
def unicode(self):
return self.question
class Choice(models.Model):
# ...
def unicode(self):
return self.choice
I've tried a few places with no sucess in runing the shell.
Change History (1)
comment:1 Changed 8 years ago by
Note: See TracTickets for help on using tickets.
Please dont' use trac for asking support questions, use either #django on freenode or the django-users mailing list. | https://code.djangoproject.com/ticket/11324 | CC-MAIN-2017-34 | en | refinedweb |
1 August 2011
By clicking Submit, you accept the Adobe Terms of Use.
You should be familiar with ActionScript 3 and object-oriented terminology and principles. Some experience with frameworks is useful, but not required. Be sure you have first read Part 1: Context and mediators.
Intermediate
This is the second part of my introductory series covering Robotlegs AS3. In the first part in the series you learned what Robotlegs AS3 is and had a brief "HelloWorld" introduction to the Robotlegs Context and Mediator classes. If you missed it, check out Part 1: Context and mediators. This article expands on those concepts and introduces models. is calculated. The new total is then.. There are many common sets of data that can easily transport between one application and the next. As an example, think of a UserLoginModel or a ShoppingCartModel. Portability takes a bit more thought and energy, but no more than writing the same code over again for each project does.
The model deserves a lot of attention. It. With the basic definition of the model in hand, let's look at a small example application.
This pure ActionScript 3 application makes use of Keith Peters's awesome Minimal Comps library. Don't worry, if you love Flex (and how could you not?) the next example will be a Flex app, but Minimal Comps makes it so easy to make quick examples with ActionScript 3,. You can download the archived Flash Builder project, which includes the Robotlegs 1.1 and MinimalComps SWC files as well, at the top of this article page.
SimpleListExample.as
public class SimpleListExample extends Sprite { public function SimpleListExample() { stage.align = StageAlign.TOP_LEFT; stage.scaleMode = StageScaleMode.NO_SCALE; } }
This is the main file of the application, the entry point. It is a simple Sprite. This is a Robotlegs application, so the first thing we need to do is create a Context:
SimpleListExampleContext.as
public class SimpleListExampleContext extends Context { public function SimpleListExampleContext(contextView:DisplayObjectContainer) { super(contextView); }); } }
It is common in Flex applications to leave out the constructor completely as the
contextView is set inside the MXML declaration. Since this is an ActionScript application, you want to pass the
contextView into the constructor so that it can be set immediately. Now let's create an instance of the SimpleListExampleContext in the main application view:
SimpleListExample.as
public class SimpleListExample extends Sprite { public var context:SimpleListExampleContext; public function SimpleListExample() { stage.align = StageAlign.TOP_LEFT; stage.scaleMode = StageScaleMode.NO_SCALE; context = new SimpleListExampleContext(this); } }
You should notice the context variable. It is important to have a reference to your context held in memory. If you were to simply create a new instance of SimpleListExampleContext in the constructor without placing it into a variable, it would be garbage-collected at the whim of Flash Player. This can cause some seriously confusing hours of troubleshooting! With Flex, you simply declare the context in MXML which holds on to the reference without needing the variable, unless you create the context in the Script tag. It will require a reference there just like the above ActionScript example.
This application will have two views: a list of names that can be selected and a text area that displays a quote from the selected item in the list. Those two views are called:
No sense being too creative with the naming scheme here. Both these views are simple sub-classes of base Minimal Comps classes. Here they are:
ListView.as
public class ListView extends List { public function ListView(parent:DisplayObjectContainer) { super(parent); } }
QuoteTextArea.as
public class QuoteTextArea extends TextArea { public function QuoteTextArea(parent:DisplayObjectContainer) { super(parent); } }
This application has only one all
public class SimpleListExample extends Sprite { private var hbox:HBox; private var list:ListView; private var quoteText:QuoteTextArea; public var context:SimpleListExampleContext; public function SimpleListExample() { stage.align = StageAlign.TOP_LEFT; stage.scaleMode = StageScaleMode.NO_SCALE; context = new SimpleListExampleContext(this); } /** * Called from ApplicationMediator's onRegister() */ public function createChildren():void { hbox = new HBox(this,0,0); addChild(hbox); list = new ListView(hbox); list.alternateRows = true; quoteText = new QuoteTextArea(hbox); quoteText.editable = false; quoteText.selectable = false; } }
You might be wondering why not just add the views in the constructor? I prefer to let Robotlegs get started before adding the children. By calling
createChildren() from the ApplicationMediator, we are 100 percent certain that all of the primary application bootstrapping is done and we are good to go. Here is the ApplicationMediator:
ApplicationMediator.as
public class ApplicationMediator extends Mediator { [Inject] public var view:SimpleListExample; override public function onRegister():void { view.createChildren(); } }
public class AuthorModel extends Actor { private var _list:Array; public function get list():Array { if(!_list) initializeList(); return _list; } protected function initializeList():void { var twain:Author = new Author("Twain"); var poe:Author = new Author("Poe"); var plato:Author = new Author("Plato"); var fowler:Author = new Author("Fowler"); twain.quote = "Why, I have known clergymen, good men, kind-hearted, liberal, sincere" + ", and all that, who did not know the meaning of a 'flush.' It is enough " + "to make one ashamed of one's species."; fowler.quote = "Any fool can write code that a computer can understand. " + "Good programmers write code that humans can understand."; poe.quote = "Deep into that darkness peering, long I stood there, wondering, " + "fearing, doubting, dreaming dreams no mortal ever dared to dream before."; plato.quote = "All things will be produced in superior quantity and quality, and with greater ease, " + "when each man works at a single occupation, in accordance with his natural gifts, " + "and at the right moment, without meddling with anything else. "; _list = [twain,fowler,poe,plato]; } }
public class Author { public var name:String; public var quote:String; public function Author(name:String) { this.name = name; } /** * Minimal comps took issue with toString(); * @return * */ public function get label():String { return name; } }
override public function startup():void { injector.mapSingleton(AuthorModel); mediatorMap.mapView(SimpleListExample, ApplicationMediator); }, I
public class ListViewMediator extends Mediator { [Inject] public var view:ListView; [Inject] public var authorModel:AuthorModel; override public function onRegister():void { view.items = authorModel.list; } }
override public function startup():void { injector.mapSingleton(AuthorModel); mediatorMap.mapView(ListView, ListViewMediator); mediatorMap.mapView(SimpleListExample, ApplicationMediator); }ator's. You still have a ways to go.
Now we want to fill the QuoteTextArea with some text—preferably a quote from the selected Author. To do that, we will be making additions to the AuthorModel so that it keeps also need to create a mediator for the QuoteTextArea so that it can listen for that event and update with the quote from the selected Author. We know we will need the event, so let's make that first:
SelectedAuthorEvent.as
public class SelectedAuthorEvent extends Event { public static const SELECTED:String = "authorSelected"; private var _author:Author; public function get author():Author { return _author; } public function SelectedAuthorEvent(type:String, author:Author = null, bubbles:Boolean = false, cancelable:Boolean = false) { super(type, bubbles, cancelable); _author = author; } override public function clone():Event { return new SelectedAuthorEvent(type, author, bubbles, cancelable) } }
The event is rather unremarkable. It is a typical custom event with a single constant, SELECTED, for a type and an optional author parameter. Now that we have the event, we need to update the AuthorModel to keep track of the selected Author and notify the application when it has changed:
AuthorModel.as
private var _selected:Author; public function get selected():Author { return _selected; } public function set selected(value:Author):void { _selected = value; dispatch(new SelectedAuthorEvent(SelectedAuthorEvent.SELECTED, selected)); }
override public function onRegister():void { view.items = authorModel.list; addViewListener(Event.SELECT, handleSelected) } private function handleSelected(event:Event):void { authorModel.selected = view.selectedItem as Author; } update let's get it mediated:
QuoteTextAreaMediator.as
public class QuoteTextAreaMediator extends Mediator { [Inject] public var view:QuoteTextArea; override public function onRegister():void { addContextListener(SelectedAuthorEvent.SELECTED, handleSelectedAuthorChanged) } private function handleSelectedAuthorChanged(event:SelectedAuthorEvent):void { var author:Author = event.author; view.text = author.quote; } }); }
You now have an example that covers the basics of using models in a Robotlegs application. The guardians of your data, models, play an extremely important part in your applications. By utilizing models as the access point for your data, you isolate where the data is stored and manipulated. When you sit down to solve a problem, you know where to look for issues regarding data and its subsequent representation of the state of your application. If your data is scattered across your application, it becomes a murky stew making it difficult to isolate trouble spots quickly or add functionality to the application.
This has been a very brief introduction to models. I highly recommend diving into some research on the M in MVC. In the next part, I will take a look how services a 25-minute screencast of mine. John Lindquist has a Hello World screencast on his blog. 3: Services.
This work is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License. Permissions beyond the scope of this license, pertaining to the examples of code included within this work are available at Adobe. | https://www.adobe.com/devnet/actionscript/articles/intro-robotlegs-pt2.html | CC-MAIN-2017-34 | en | refinedweb |
An Amazon interview question (not completely solved)
Given
red balls and
blue balls and some containers, how would you distribute those balls among the containers such that the probability of picking a red ball is maximized, assuming that the user randomly chooses a container and then randomly picks a ball from that?
Solution (probably)
The solution to this problem works as follows: Take all your
red balls and put them one by one in one container after another until you have no balls left. If there are containers left (i.e. without red balls), take your blue balls and distribute them as you like into the remaining containers. If there are no containers left, take all your blue balls and put them in one arbitrary container.
To prove this (at least one case), we first do some definitions:
W.l.o.g I assume
, i.e. all containers can be filled with at least one ball.
Let's call the number of containers
.
denotes the event that container
is choosen.
denotes the event that a red ball is chosen from the
-th container. The probability of choosing the
-th container is (since we have
containers in total)
.
Let
denote the number of red balls in container
and
denote the number of blue balls in container
. It is obvious that
.
So the probability of choosing a red ball from container
if we chose container
already, is
.
No we can use a case differentiation:
Case 1:
In this case, we have
containers containing exactly 1 red ball and
containers containing either one or more blue balls. So the probability of picking a red ball according to the proposed experiment, is
.
Proving that this probability is maximal is not very hard: We know, that at most
summands can be positive (since containers with no red balls yield a probability of 0 and we have exactly
red balls). We know further, that
. Therefore we know, that the maximal probability in this case is
as stated above.
Case 2:
(unsolved)
Here we have at least one red ball in each container. More precisely, we have
containers with exactly one red ball, and one container holding
red and
blue balls. The probability of picking a red ball can then be computed as
.
The above can be simplified to
.
To prove that this is the optimal probability is quite difficult (as far as I can judge it).
We have to fill all
containers. For all
holds that
.
If we distribute the balls according to the above rule, we have
containers with just one red ball, i.e. choosing one of these
containers directly leads to picking a red ball. Just one single container has a probability of less than
. More formally,
(there exists exactly one
such that)
. Moreover
.
If we choose any other distribution, there are at least two values
such that
and
.
Let [k'.png](img/k'.png) the number of summands that are equal to
. That is, we have [k-k'.png](img/k-k'.png) summands remaining that have to sum up to something greater than [dfrack-1-k'k + dfrac1k cdot dfracn-(k-1)n-(k-1)+m.png](img/dfrack-1-k'k + dfrac1k cdot dfracn-(k-1)n-(k-1)+m.png).
I do not know how to prove (or disprove) the second case.
If you can't prove, test it!
Since I was not able to prove the second case, I wrote some lines to test it experimental. Below you find some code to simulate the experiment and determine the best distribution:
def p(l): sum = 0 for (n,m) in l: if (n>0): sum = sum + (1/len(l))*(n/(n+m)) return sum def distribute(n,k): #distributes n balls into k urns if (k==1): yield [n] return for i in range(n+1): for d in distribute(n-i, k-1): yield [i] + d def bestDist(n,m,k): return max([(p(list(zip(l1,l2))),list(zip(l1,l2))) for l1 in distribute(n,k) for l2 in distribute(m,k)])
bestDist(n,m,k) returns a tuple consisting of the maximal probability and the corresponding Distribution. For example, the tuple
(0.8, [(1, 4), (1, 0), (1, 0), (1, 0)])
means, that we have a maximal probability of 0.8, that occurs if we distribute 1 red ball and 4 blue balls into container 1, 1 red ball and 0 blue balls into container 2, 1 red ball and 0 blue balls into container 3, 1 red and 0 blue ball into container 4.
Experimental results
>>> bestDist(2,2,2) (0.6666666666666666, [(1, 2), (1, 0)]) >>> bestDist(3,3,3) (0.75, [(1, 3), (1, 0), (1, 0)]) >>> bestDist(4,4,4) (0.8, [(1, 4), (1, 0), (1, 0), (1, 0)]) >>> bestDist(5,5,5) (0.8333333333333335, [(1, 0), (1, 0), (1, 0), (1, 5), (1, 0)]) >>> bestDist(6,6,6) (0.8571428571428571, [(1, 0), (1, 0), (1, 0), (1, 6), (1, 0), (1, 0)]) >>> bestDist(5,4,3) (0.8095238095238095, [(3, 4), (1, 0), (1, 0)])
As you can see, the distribution is always such that we have
containers with exactly 1 red ball and 0 blue balls. One single container is filled with
red and
blue balls.
The simulation experiments I've done lead one to assume that the strategy is correct.
Hints for solving this quiz mathematically are highly appreciated... | http://phimuemue.com/posts/2011-01-24-an-amazon-interview-question-not-completely-solved.html | CC-MAIN-2017-34 | en | refinedweb |
Auraria Home
|
CU Denver Theses
myAuraria Home
"Linguistic geometry methods for autonomous, mobile robot control"
Item menu
Print
Send
Add
Description
Standard View
MARC View
Metadata
Usage Statistics
PDF
Downloads
Thumbnails
Page Images
Standard
Zoomable
Citation
Permanent Link:
Material Information
Title:
"Linguistic geometry methods for autonomous, mobile robot control"
Creator:
Fletcher, Christopher Martin
Place of Publication:
Denver, CO
Publisher:
University of Colorado Denver
Publication Date:
1996
Language:
Physical Description:
131 leaves : illustrations ; 29 cm
Subjects
Subjects / Keywords:
Artificial intelligence ( lcsh )
Linguistic geometry ( lcsh )
Mobile robots ( lcsh )
Robotics ( lcsh )
Genre:
bibliography ( marcgt )
theses ( marcgt )
non-fiction ( marcgt )
Notes
Bibliography:
Includes bibliographical references (leaf 131).
Thesis:
Submitted in partial fulfillment of the requirements for the degree, Master of Science, computer science
General Note:
Department of Computer Science and Engineering
Statement of Responsibility:
by Christopher Martin Fletcher.
Record Information
Source Institution:
University of Colorado Denver
Holding Location:
Auraria Library
Rights Management:
All applicable rights reserved by the source institution and holding location.
Resource Identifier:
37311907 ( OCLC )
ocm37311907
Classification:
LD1190.E52 1996m .F54 ( lcc )
Auraria Membership
Aggregations:
Auraria Library
University of Colorado Denver Theses and Dissertations
Downloads
This item has the following downloads:
Fletcher_Christopher.pdf
Full Text
PAGE 1
"LINGUISTIC GEOMETRY METHODS FOR AUTONOMOUS, MOBILE ROBOT CONTROL" by Christopher Martin Fletcher A thesis submitted to the University of Colorado at Denver in partial fulfillment of the requirements for the degree of Master of Science Computer Science 1996
PAGE 2
This Thesis for the Master of Science degree by Christopher Martin Fletcher has been approved by Boris Stilman Tom Altman
PAGE 3
Fletcher, Christopher Martin (M.S., Computer Science) Linguistic Geometry Methods for Autonomous, Mobile Robot Control Thesis directed by Professor Boris Stilrnan ABSTRACT Autonomous robots have been a practical goal of artificial intelligence research since the beginning of the field. Dexterous, decision-making automatons will permit reconnaissance of hazardous environments and enhance the exploration of space. While robots have made inroads into the factory to execute repetitive tasks, widespread use of mobile intelligent robots has not been realized. This has been due chiefly to the inability of a robot to successfully interact in a dynamic environment. A key factor is that the software has not been adept at reacting to changes in the domain. Moreover, there is a lack of formal methods to represent knowledge and systematic changes in this class of problems. A linguistic approach is proposed in this thesis as the basis for robot control in complex environments. Linguistic geometry provides a formal mechanism for representing knowledge and reasoning in the general class of problems of controlling movement in a complex system. Practical applications include: robotics, scheduling, control systems, military gaming, etc. The approach is rooted in the theory of formal languages as well as the theories of problem solving and planning. This thesis presents a linguistic approach for geometric reasoning and applies the technique to a simulated mobile, autonomous robot operating in a dynamic environment. The software application will demonstrate the ability of this approach to successfully generate solutions to complex scenarios encountered by a mobile robot. This thesis will demonstrate how these geometric reasoning methods can be successfully applied to a realistic, intelligent robotic system. This abstract accurately represents the content of the candidate's thesis. I recommend its publication. Boris Stilman
PAGE 4
CONTENTS 1. Introduction ..................................................................................................................... 1 2. Linguistic Geometry Methods ........................................................................ ................ 5 2.1 Knowledge Representation ............................................................................................ 5 2.2 State Transition in the System ..................................................................................... 7 3. Mobile Robot Planning and Motion Generation .................................................... ...... 12 3.1 Knowledge Representation .......................................................................................... 12 3.2 Robot Path Planning in a Simple Environment .......................................................... 16 3.2.1 Software Design ........................................................................................................ 16 3.2.1.1 Objects ................................................................................................................... 16 3. 2. 1. 2 Methods ................................................................................................................. 20 3.2.1.3 Classes ................................................................................................................... 21 3.2.2 Test Results ............................................................................................................. 24 3.3 Robot Path Planning in an Environment with Obstacles ........................................... 28 3. 3.1 A Language of Admissible Trajectories .................................................................... 29 3.3.2 Design Augmentation ............................................................................................... 32 3.3.3 Objects ...................................................................................................................... 32 3.3.3.1 Methods ................................................................................................................. 33 3.3.3.2 Classes ................................................................................................................... 35 3.3.4 Test Results .............................................................................................................. 38 3. 3. 4.1 "Walls" Scenario ..................................................................................................... 39 3.3.4.2 "Rooms" Scenario ................................................................................................... 47 3.3.4.3 Invisible Obstacles Scenario .................................................................................. 54 3.4. Robot Path Planning with Static and Dynamic Obstacles ......................................... 57 3.4.1. Trajectory Networks ................................................................................................ 59 3.4.2. Design Augmentation .............................................................................................. 61 3.4.2.1. Objects .................................................................................................................. 61 3.4.2.2. Methods ......................................................... ...................................................... 63 3.4.2.3. Classes ...................................................................... ........................................... 65 3.4.3. Test Results ............................................................. . .... .......................................... 67
PAGE 5
3.4.3.1. Single Dynamic Obstacle Scenario ....................................................................... 68 3.4.3.2. Multiple Dynamic Obstacle Scenario ................................................................... 73 3.4.3.3. Static and Dynamic Obstacle Scenario ................................................................ 78 4. Summary and Conclusion ............................................................................................. 87 Appendix A Mobile Robot Simulation Software ................................................................ 91 Appendix B Source Code ................................................................................................... 96 Bibliography .................................................................................................................... 131
PAGE 6
1. INTRODUCTION Research into autonomous, mobile robots has flourished recently due to the tremendous reduction in the size and cost of components especially sufficiently powerful computers. However, the problems encountered by mobile robotic systems remain considerable. A mobile robot operates in the physical world. This world can be uncompromisingly dynamic and unpredictable. Consequently, an intelligent agent must continually monitor a situation and adapt its current and planned activity to a changing environment. In addition to the volatility of the environment, the area of operation may be too complex to fully represent. Thus, an agent may be capable of comprehending only a portion of the domain. Timeliness is another constraint facing autonomous robots. Mobile robots must perform in real-time. Obviously, the criticality is paramount in certain applications, e.g. an autonomously operating airplane versus a mail delivery robotic system, but some measure of a real-time capability is required in all such systems. Why choose to implement totally autonomous systems? There are applications where manual (remote) or semi-autonomous control of a vehicle operation is sufficient. Many applications, however, inherently prevent human interaction. Today, mobile robotic systems are being designed to work in conditions extremely detrimental to humans and where external communications are hampered by the environment. One such system detailed in [MMAG, 1991] is an inspection robot that operates in a hazardous waste facility, evaluating storage container integrity. Additionally, there are scenarios where the situation changes rapidly and at great distances from any possible human intervention. Applications common to this domain. are exploration and reconnaissance. The exploits of the robot Dante exploring an active volcano recently generated front page news. Finally, there is a class of mostly military systems where communications may be impossible due to potential interference or detection by an opposing force. Applications in this domain include covert surveillance, and search and rescue operations. A primary theme shared in all such systems is the removal of direct human 1
PAGE 7
involvement due to the danger and remoteness involved. Furthermore, they require an intelligent, decision-making capability independent of human intervention. The application investigated in this thesis is one of a simulated autonomous robotic vehicle operating in a complex environment. This mobile robot is assigned a task to complete to reach a pre-determined destination or point of interest in the most optimal manner possible. The vehicle operates under some real-world constraints. It may only travel at a limited velocity on a fmite 2-D plane. The robot possesses only limited knowledge about the operational area. This restriction is manifested as a limited field of view. A robot may be re-tasked to a new destination based on changing priorities. A robot must be flexible allowing for new tasking at any point along its travels. Finally, there are obstacles in the area that inhibit free movement. The obstacles may possess any shape and size. They may also move, disappear and reappear in new locations at will. Under these constraints the mobile robot plans paths to a point of interest and executes movements along selected paths until the task is complete. There are several considerations for an intelligent agent operating in these surroundings. One factor is the representation of knowledge. Information concerning the area of operation, the obstacles, the robot itself, and the decision making process must be represented in a manner that streamlines path generation and execution. Functioning in a dynamic environment presents difficulties in knowing how the knowledge base is affected by change. That is, reflecting what has and what has not changed without reconsidering every piece of knowledge. Elements of change in the scenario include: obstacle location and size, destination, and robot location. Finally, there is the search problem. From any location in the area many paths can be considered. Which path takes it closer to the destination? Which is the best path? A comprehensive approach, considering all possible paths, often fails real-time criteria. A strategy is needed to quickly generate only the most promising paths. The approach must consider the short term goal of optimal movement within the field of view as well as the long term goal of premium movement towards the destination. One of the basic ideas in finding solutions to a system is to break it into smaller sub-problems to be solved and then combine the solutions to the smaller problems together to resolve the whole system. This approach suffers generally due to the complexity of real-world 2
PAGE 8
systems. The subsystems are seldom independent and the solutions to these subsystems are, therefore, dependent on the solutions to other subsystems. This research presents an approach for formulating paths and executing movement on the paths that permit the vehicle to reach its destination in an optimal manner. At the core of this proposal is Linguistic Geometry, a concept for reasoning in this class of problems. Linguistic geometry formalizes a mathematical model for the representation of general heuristic knowledge and provides the search infrastructure for deriving an optimal solution. The theory traces its roots back to the early 1960s, with the development of a syntactic approach to natural language. The development of formal grammars by Chomsky (1963) led to application of this research in other new areas. In particular, grammars were utilized for pattern recognition by Fu (1982), Narisimhan (1966), Pavlidis (1977) and picture descriptions languages by Shaw (1969), Feder (1971), and Rosenfeld (1979). Stilman applied similar techniques to hierarchical complex systems evolving into linguistic geometry. The PIONEER project provided the early framework for linguistic geometry. PIONEER is a system that investigated applying sophisticated human heuristics to computer-based chess. This research resulted in an implementation that produced highly selective searches. This framework was also successfully adapted to a power control and maintenance planning project [Stilman, 1992]. Very recent applications include: a real-time fire vehicle routing application currently being developed into a commercial project under the auspices of the Lockheed Martin corporation, and a high integrity software engineering application to provide the computer-assisted generation of mathematical proofs for software programs. This research is being conducted at the Sandia National Labs. The remainder of this thesis explores linguistic geometry as applied to the mobile robot scenario. Section 2, Linguistic Geometry Methods, presents the theory of linguistic geometry. This includes description of the system variables and a description of movement and state transition. A derivation of a grammar of shortest trajectories is also presented. Section 3, Mobile Robot Planning and Motion Generation, introduces the mobile robot application. It is here that the linguistic technique is applied to the robotic system. The application is examined in this discussion from the representation 3
PAGE 9
of knowledge to the software design and implementation. The shortest trajectory algorithm is augmented through the introduction of the grammar of admissible trajectories. This extension generates optimal (shortest) trajectories and sub-optimal paths. Sub-optimal paths may be required in the presence of obstacles blocking the optimal routes. Various test cases are illustrated and the results are weighed. Appendix A follows the conclusion of the thesis describing the robot simulator software used for robot software testing and visualization. 4
PAGE 10
2. LINGUISTIC GEOMETRY METHODS This chapter introduces the reader to a linguistically based, mathematical tool for heuristic knowledge representation and search generation in a complex system. A complex system is a class of problems that can be represented as a set of elements and positions where elements transition from one state to another. Dividing the problem into a hierarchy of dynamic subsystems replaces a static system with a single goal. The goals of each of the subsystems are independent, but coordinated to the system goal. Linguistic geometry represents the hierarchy of dynamic subsystems with a hierarchy of formal languages. Each sentence a group of words or symbols of a lower level language corresponds to a word of the next higher level language. The first level grammar, the language of trajectories, yields a set of symbols and parameters as illustrated below. a(x1)a(x2)a(xa) ... a(xn) The variables, XI through Xn are the domain specific knowledge of the system. For example, in the mobile robotic system control application, the variables might represent discrete map locations on the planned path of the robot. Second and third level languages build on the strings produced by the language of trajectories to produce higher level decision strings applicable to the environment. Initially, we concentrate on the language of trajectories as a method to create paths. 2.1 KNOWLEDGE REPRESENTATION To begin, there must exist some techniques for formally representing knowledge. Definition of a Como lex System A definition of a complex system [Stilrnan, 1993] is described by the following 8 tuple: (X,P ,Rp,ON ,V ,Si,St,TRANSITION) where: X= {xi) a finite set of points that define locations in an area. 5
PAGE 11
P = {p;J a finite set of elements that define the dynamic objects of the model. P is the union of two non-intersecting subsets: p, and P2. RP (x,y) is a set of binary functions of reachability in X. Where: x, y are cells from X. pis a member ofP. RP (x,y) is true if element p located at cell x can reach cell y. Otherwise, it is false. ON(p) = x where ON is a partial function of placement from Ponto X. Vis an evaluation or cost function for the set P depicting a value associated with each member. S; is the description of the set of initial states of the system by a certain collection ofWell Formed Formulas ofthe first order predicate calculus: {ON(p;) =Xi} s, is the description of the set of target states of the system. TRANSITION(p,x,y) is the description of the operators for transition of the system from one state to another. If an element p wants to transition from its current location x to a new location y, it is described by the following states: precondition: delete: add: 6 ON(p) = x & Rp(x,y) ON(p) = x ON(p) = y
PAGE 12
Representation ofDistance Geometric properties of the system are a key representation concept in linguistic geometry. In linguistic geometry, distance, measured as the minimum amount of time required to reach a given location, is represented in a mapping (MAP) function. This function uses the notion of Rp(x,y), the reachability of locations in the domain. Critical to MAP is the concept that a set of locations is reachable in a certain amount of steps and is not reachable in any less. Figure 2.1 illustrates this concept. The set Mkx.p is a fmite subset of points from the set X specific for element p and for a given location x. Its membership is made up of cells that are reachable in k steps from x and are not reachable in k-1 or fewer steps. Stated formerly, is the set of all Mkx.P (k=l,n) where the Rp(x,y) is true and n is the number of steps from x to y. We apply this function in the next section to help in constructing a grammar of shortest trajectories. Figure 2. 1 Reachability for a MAP Function 2.2 STATE TRANSITION IN THE SYSTEM A Language of Shortest Trajectories Assume a robot must generate optimal trajectories from a start location xo to a destination location yo. The robot possesses a MAP of distances between locations in a fixed domain. We wish to generate strings of locations that describe the optimal path(s) a robot may travel to reach a pre-determined destination. Table 2.1 is a presentation of the controlled Grammar GtO> of Shortest Trajectories that is capable of generating the strings [Stilman, 1993]. 7
PAGE 13
L 1 2i 3 Table 2. 1 Grammar of Shortest Trajectories Q Q1 Q2 Q3 Vr ={a}, VN = {S,A}, VPR = Kernel, rr .. A(x,y,l) A(x,y,l) Pred = {Q1, Q2, Q3} Q1(x,y,l) =
PAGE 14
MOVEt(x) =SUM n STt(x) n STto.J+t(xo) if MOVEt(x) = {mt, m2, ... mr} != 0 then The MOVE set at length l is not empty nexti (x, l) = mi for i :::::; r next returns each member of set per reference else nexti (x, l) = x end if MOVE is empty robot has no next move In order to facilitate understanding of Gt
PAGE 15
5 5 5 5 5 5 4 4 4 4 4 5 3 3 3 3 4 5 2 2 2 3 4 5 I I 2 3 4 5 0 I 2 3 4 5 I 2 3 4 5 61 Figure 2.2 6x6 Example Domain At this stage, we encounter two functions. The function f is trivial, simply subtracting 1 from the current length of the trajectory. The next function produces the a member of the set of next possible locations in the trajectory. This is an iterating function that returns a new value with each application, until there are no more. Iteration is indicated by the i subscript. Function next is the result of intersecting three sets. The first, SUM, contains cells that on-the-way to the destination. At least one trajectory will pass through each of these SUM cells. A cell is on-the-way when the MAP' ed distance from the start to a cell is summed with the distance from the same cell to the destination is exactly the total distance from start cell to the destination cell. In our example, this set is: { (1, 1); (2, 1); (2,2 ); (3,2 ); (3, 3); ( 4, 3); ( 4,4 ); (5, 4)} The second set, STk, contains those cells that are reachable from the starting location in exactly lo-1+ 1 steps. In the example, k = 1. This set is: { (2, 2); (2, 1); (1,2)} The fmal set, ST1, contains cells that are reachable from the current cell in exactly one step. Of course, at step = 1 this is the same set as STk. So, the intersection of the sets is: {(2,1);(2,2)} The application of production 2, combined with the next evaluation produces: A((1, 1),(5,4),4) _. a((1, 1))A(2, 1), (5,4), 3) _. a((1, 1))A((2,2),(5,4), 3) Predicate Q2 is a check for 1 >= 1. With 1 = 3, this evaluates to true and we execute jump to branch two. Production 2, expressed in this manner, is meant to indicate new 10
PAGE 16
productions should be applied in parallel to all non-terminals generated from previous applications. The grammar continues in this fashion until the value of length decrements to 0. At this stage, repeated applications of production 2 has resulted in the following strings: -+ a(l, 1)a(2, 1)a(3,2)a(4,3)A((5,4), (5,4), 0) -+ a(1, 1)a(2,2)a(3,3)a(4,4)A((5,4),(5,4),0) -+ a(l, 1)a(2,2)a(3,2)a(4,3)A((5,4),(5,4),0) -+ a(l, 1)a(2,2)a(3,3)a(4,3)A((5,4),(5,4),0) Each production fails the predicate check, Q2(0);t (l 1), and moves to production 3. This production adds the destination a(5,4) to the string. The result of executing this grammar is that the robot has planned all optimal paths from the initial location (1, 1) to the destination location (5,4). For this scenario, all of the paths are essentially as optimal as the next. So, to reach the destination all that remains is for the robot to select a path upon which to move and to generate movement on the trajectory. 11
PAGE 17
3. MOBILE ROBOT PLANNING AND MOTION GENERATION This section introduces a robot planning and motion engendering application utilizing a linguistic geometry control model. The application employs a robot that must plan and execute a path from its current location to a destination location. The robot is staged in increasingly complex environments --from no obstacles, to static obstacles, to dynamic obstacles. Each enhancement to the model is measured with regards to the impact on the design and implementation, as well as the performance of the design. We measure performance in several ways. First, the robot must be able to execute its tasks in the most optimal manner supported by the environment. A key feature of this requirement is the ability of the software to plan and execute a task without search inefficiencies or backtracking. Second, the robot shall be capable of responding to changes in the domain. A key feature of this requirement is the effectiveness of the software in recognizing systematic changes and reacting. The first requirement still applies in these situations, so the software must implement changes in the most optimal manner available. Third, the robot shall execute tasks in a timely fashion. Success at each stage will be demonstrated via computer simulation. Features of the robot: field of view, speed and the work area: size, obstacle location are parameters of this simulation. Appendix A details the simulation software. Section 3.1 is a review of the key concepts for representing knowledge in the linguistic geometry model. The concepts will be explored with regards to the requirements of a robot control application. Sections 3.2 through 3.5 are the design & implementation details of the robot control application. 3.1 KNOWLEDGE REPRESENTATION RePresentation of a comvlex system Earlier, a linguistic geometry model was defmed for a generic complex system. This concept is now focused on the specifics of the proposed mobile robot control paradigm. 12
PAGE 18
A complex system is defined as the subsequent 8-tuple: (X,P ,Rp,ON, V ,Si,St,TRANSITION) where: X= {xi) a finite set of points that define the arena of operation. X represents the work area where the robots operate; a 2-dimensional space divided into equally sized, atomic cells. The work area dimensions for this application will be a parameter of the simulation. Although the work area is somewhat benign in definition, calculating the distance between discrete cells, determining reachability, and representing obstacles are key design issues that are tightly coupled to the design of the work area. P = {pi) a finite set of elements that define the dynamic objects of the model. P is the union of two non-intersecting subsets: Pt and Pz. P represents the robot in the application. In the general model presented earlier, P was the sum of two sets --each representing a opposing side in a gaming or interception scenario. Initially, P will consist of the single robot under test. Dynamic obstacles, essentially functioning as an opposing element to the robot will be introduced in the fmal manifestation of the application. The robot is the source of intelligent activity in the model. It operates on the work area using methods that measure distance, determine reachability, derive trajectories, etc. Rp (:x:,y) is a set of binary functions of reachability in X. Where: :x:, y are cells from X. Pis a member ofP. Rp (:x:,y) is true if element p located at cell x can reach cell y. Otherwise, it is false. This definition directly applies to the robot control paradigm. In the simplest stage of the model, with no obstacles, the reachability relation is true for all cells that the robot can reach given the robots speed, etc. When obstacles are introduced in later stages of the design the reachability function must incorporate those cells occupied by obstacles, but still within the robots ability, to reflect an unreachable status. Cells that are 13
PAGE 19
entirely shut off from access by obstacles, as illustrated in the example below are also classified as unreachable. Unreachable Cell Figure 3.1 Unreachable cell not containing an obstacle The reachability function can not be as rigidly defmed in the presence of dynamic (moving) obstacles. A cell may be unreachable in one time interval only to be re evaluated as reachable in a subsequent time interval as an obstacle or robot moves. In this environment, the robot control implementation must provide a reachability function that incorporates another variable: the particular state of a cell at the time the function is to be applied. ON(p) = s where ON is a partial function of placement from Ponto X. This function is used to describe the cell, x, currently occupied by an element of P, i.e. a robot or a dynamic obstacle. A robot can occupy only one cell, while a dynamic obstacle may occupy one or more cells, depending upon its size. A cell is either occupied or is not occupied, i.e. there is no partial occlusion. Vis an evaluation function on the set P describing the value of each member. The evaluation function does not apply in this model. S; is the description of the set of initial states of the system by a certain collection ofWell Formed Formulas ofthe first order predicate calculus: {ON(p;) = :x:;) This set represents the initial locations in X of a robot and dynamic obstacles in the application. Both are provided their initial location as a parameter of the simulation. 14
PAGE 20
St is the description of the set of target states of the system. This set represents the destination location in X of a robot in the application. A robot will be provided its destination location as a parameter of the simulation. Obstacles in this model do not possess target states. TRANSITION(p,x,y) is the description of the operators for transition of the system from one state to another. TRANSITION characterizes change in the system. At each time interval, the change in the state of the work area is reflected in two lists. The remove list contains the current locations of the dynamic elements in the model while the add list contains the new locations, after a time step increment has occurred. Dynamic elements characterize change through their locations on the work area. Measurement ofDistance Distance measurement is a simple, but key concept in geometric reasoning. Earlier, a map component was introduced to provide elements operating in an area with the capability of determining the distance from one location to another. This paradigm carries over to the implementation of such a system. In the robot control application, a function is provided to a robot to map the distance from one cell in the work area to another. As in the theoretical presentation, distance is defmed as the smallest number of time intervals required to reach a given cell from a start cell. 15
PAGE 21
3.2 ROBar PATH PLANNING IN A SIMPLE ENVIRONMENT The initial robot control application introduced in this section contains a single robot operating in a 30x30 work area containing no obstacles A robot is defmed with two parameters Velocity is measured in units of work area cells the robot may travel in a single time interval. There are no restrictions dictating direction of travel, i.e. the robot can change direction without a loss of velocity. Field of view, the second parameter, measures how far a robot may see. This parameter, also measured in cells, defmes the visible horizon of the robot. This is a critical robot characteristic in as it defmes a local arena in which the robot plans and moves. Information about cells outside the field of view is limited to simple distance The field of view defmes a square area around the current robot location essentially simulating an omni-directional sensor capability. The robots view stops at the edges of the work area, creating a more rectangular view in those instances Two robots with slightly different functional characteristics will be presented in separate test cases. The first robot travels two cells in any direction in one time interval. It has a field of view of six cells The robot in the second example travels three cells in any direction in one time interval. It has a smaller field of view of only three cells 3.2.1 Software Design The concepts here represent the basis of the design that will be augmented in further sections as a more complex environment is introduced An object oriented methodology characterizes elements of the design using the following steps : Identify and classify objects & methods from the requirements Group objects & methods into classes Demonstrate class interaction 3 2 .1.1 Objects Location A Location object identifies a unique position in the work area. The two-dimensional presentation of the work area drive x and y attribute parts of the object. Examples of different instantiations of robot Locations are : start. current, destination 16
PAGE 22
The cell object is a single, atomic component of the work area. Prior to path planning, a cell consists only of its location tag. \Vhen a path is planned through a cell, however, it acquires other attributes describing its position in the trajectory(s). This is detailed in the following discussions of trajectory and plan. Work Area The work area is a matrix of cells. The work area dimension is set by x and y size elements supplied as parameters to the simulation. The robot is strictly confmed to this arena. At the start of a job, the work area cells are independent elements representing only locations. As a trajectory is built up defming the path plan, the cells are bound to form a network of locations over which the robot may travel to reach the job destination. Robot A robot object generates all activity in the work area. It integrates and controls all of the previously presented objects, using those objects to plan and execute movement to a goal. A robot is characterized by its speed and field of view. Mru! The map object is a critical and powerful element of the design. It is the foundation of the robot control implementation. Map represents distance from a location in the work area to another location in the work area. There are two basic approaches to designing the map. A static map plots all of the distances from a location to any other location in a pre-determined data structure. This design incorporates a relative distance map that places an arbitrary location at the center of the data structure. Other elements of the data structure are representative of delta x's and delta y's from the center of the structure (delta x = 0, delta y = 0). Each of the elements of the structure contains a distance relative from to the center location. Distance is determined from operational robot parameters such as speed and direction. When a distance calculation is needed, the starting location is mapped to the center element of the data structure. All locations adjacent to the starting location are mapped to those cells adjacent to the center, (delta x=l, delta y=O; delta x=O, delta y=l; ... ) and so on until all of the cells are assigned relative locations in the structure. For example, assume the cells adjacent to 17
PAGE 23
the center location are labeled with distances as illustrated in figure 3.2. An arbitrary location (x=lO, y=20) is assigned to the center location. The distances to all locations from (10,20) are immediately known based on each location's delta x, delta y from (10.20). Keep in mind the assignment of (10,20) to the center location is variable. If the robot is in a new location, for example (21,12), and distances are required, (21,12) is simply assigned to the center location and all distances from (21, 12) are known. The representation of the static map must be four times a large as the work area, as illustrated in the figure. This is so locations at the extremes of the work area can also be placed in the center location and still map the full extent of the work area. Also, work area boundaries must be considered when mapping dynamic locations to absolute locations. +2n +2 +1 0 -1 -2 -2n -2n -2-10 +1+2 +2n I I I I I I 2 2 2 2 2 ....... 2 1 1 1 2 2 1 \ 1 2 ....... 2 2 2 \2 2 ....... 3 \ 3 :\ Center Loc Figure 3.2 Static Map Representation of distances from (10,20) A dynamic map requires that only operational parameters, e.g. speed and direction coefficients of a robot be stored. Distances are computed based on the difference between the x coordinates and the y coordinates of two locations, and factoring in the speed of the robot. A simple algorithm for dynamic distance is presented below. Max_ Diff MAX ( ABS ( Startz Finish:), ABS ( Starty Finishy)) DistfttrJ.JII MaxDo/Robot_ Speed + (Max_ Diff% Robot_ Speed) There are advantages to both kinds of Map representation. The static map is particularly useful for fmding all cells in a particular set. For example, to determine all cells that are a distance 5 from location (20,20) involves assigning (20,20) to the center location and searching the static structure to fmd all locations that are a distance of 5. With the dynamic map, a distance must be calculated from the start location to each 18
PAGE 24
location in the work area (or within the robot field of view) to determine if that location is in the set. A static map also distinguishes the extent of blocking by an obstacle. The dynamic map provides a greater advantage when we consider a more complex environment .. Since the static map works off of relative locations and not absolute, it can not consider obstacles in the environment. Obstacles also affect distances in the static map. More detail will be provided in later sections when obstacles are considered. So, for the simple environment presented here, we will use the static map. Trajectory The notion of a trajectory was introduced in previous sections. In the implementation, a trajectory is a path on the work area from a start location to a destination. It is formed by linking cells in a parent-child relationship. A parent is a predecessor cell from which a given cell can be reached in a trajectory. A child is a successor cell that a given cell can reach. The decision logic to link cells in a parent child relationship is the result of the linguistic geometry path planning algorithm. 1 1 1 2 3 4 Figure 3.3 Cells Linked to Form a Trajectory The relationship between cell, trajectory, and path plan objects is the central theme of the implementation. (Path) Plan A path plan object is a bundle of trajectories from a start location to a destination for a given job. This is the network that is formed by generating all of the trajectories that provide a shortest path. Trajectories may coincide with other trajectories, along the same path, at a particular cell. It is important to the design that these coinciding cells be the same in one trajectory as in another. That is, a cell must be instantiated once in a plan. All trajectories passing through that location must be passing though the same cell and not a copy. There are two reasons for this. First, there is a gain in efficiency in only expanding a cell's children once. If another trajectory passes through the same 19
PAGE 25
cell, then the children, and their children, are already in place. An additional benefit is gained when obstacles are introduced. If a cell is blocked from access, it must inform only one set of parents. Time Interval A time interval is perhaps more appropriately presented as part of the simulation. It is mentioned in this design section since it is the attribute that drives action in the application. Time is an artificial notion in the design that does not typify a temporal object as much as it represents a functional object. In this regard, time is closely related to the Reachability function. A robot's speed is a defmed in terms of how many cells it can travel in a single time interval. 3. 2. 1. 2 Methods Generate Transition Locations Since a robot may not have the sensor capability to completely plan to the destination location, there must exist a method to select intermediate locations along the way to the fmal destination. Through the Map object, the robot possesses the knowledge of relative distances between cells in the work area. This method must select optimal transitional cells that are within the robot field of view and bring the robot optimally closer to the destination. The most optimal transition locations are those that utilize the full extent of the field of view and that bring the robot the nearest to the destination location. Plan a Path Planning a path is the method through which trajectories are generated from a start to the selected transition locations. In this implementation, this is accomplished through the language of shortest trajectories. 20
PAGE 26
Execute a Path Upon executing the method to plan a path, the robot has not yet moved. The Execute method moves the robot on a path to the destination location. At this point in the application, with no obstructions in the work area, any of the trajectories chosen suffice as a shortest path. Calculate Distance A method to calculate distance is required in many steps of planning a path. The characterization of the map object makes this method a table search. 3.2.1.3 Classes The objects and methods of the robot control design are compiled into the classes illustrated below. The robot class drives the generation and movement along a path in this scenario. Upon user selection, the simulator creates a Robot object defming as its parameters: speed, and field of view. The robot creates a Robot Map object for itself providing work area size as a parameter. The Area Map constructor creates the static map, calculating relative distance from the center location. The absolute area, an array of cells, is created and initialized. Two utility classes, implemented as templates, are utilized in the planning algorithm. The List class, is a double linked list used as a container for Cells in the algorithm. A Set container inherits from List. The Set class characterizes methods for the intersection and union of cells. 21
PAGE 27
ROBOT SIMULATOR """' ExecutA Get Path Info Create De AREA MAP Move let
PAGE 28
algorithm when the robot reaches a field of view boundary. So, since the planning algorithm produces cells that are along a shortest trajectory and no others, the Execute Move method is guaranteed an optimal path to the destination location. 23
PAGE 29
3.2.2 Test Results Implementation results are presented in two test cases. The first simulation initially places a single robot at grid location 14, 14. The robot in this test is capable of moving two cells in a single time interval and has a horizon of six in all directions. The destination location is set to 0,5. So, at two cells per time interval, the robot should, optimally, attain this location in seven time steps. The test results illustrated below demonstrate the planning and movement done to attain the goal. In the first frame, the robot has performed the initial planning required to move towards the destination location. Since the destination is not within the field of view, the robot can only travel to the frontier of the extent and then must replan. The dark, thin lines in the frame represent the planned trajectories. The lighter, thicker single line illustrates the selected path moved upon by the robot. In the second frame, the robot has reached the view frontier and has planned again. This time, the destination is within the robot view and all trajectories terminate at the destination. The third frame shows the fmal path of the robot from start to destination. Robot Path Generator Simulation 6 6 6 6 6 6 6 6 6 6 6 6 6 6 5 5 5 5 5 5 5 5 5 5 5 6 6 5 4 4 5 6 6 5 4 3 3 3 3 3 3 3 4 5 B 6 5 2 2 2 2 3 4 5 6 B 5 1 1 2 3 4 5 6 6 123.56 1 2 3 4 5 6 2 2 2 3 5 6 3 3 3 3 3 3 4 5 6 4 4 5 6 5 5 5 5 5 5 5 5 5 5 6 6 6 8 6 6 6 6 6 6 6 6 6 29 28 27 28 25 24 23 22 21 20 19 18 17 16 15 1. 13 12 11 10 9 8 7 6 5 3 l-:o:-:-1 -=2:-::-3 -:-:5:--::-6 -:7-:8=-=9 7.1 o::-::171 -:-::1 2:-:-1 :::-:31:-:-4-::15:-:-1 :::-:6 2:;:::0::;:21:-:n=n:-::24:-:2;;:-5 -::;;26:-::;2:;-:7 28-:;;;-::;;29 2 1 0 0 Obstacle 0 Start Destination 181 Path Robot Definition Speed Fleld VIew [U Figure 3.5 Test Case 1/Frame 1 Planning from initial location 24
PAGE 30
,U: Robot Path Generator Simulalion 29 28 0 Obslacle 27 26 25 0 Start 24 23 Destination 22 21 8 6 6 6 8 6 6 6 6 6 6 6 6 20 D Grid 6 5 5 5 5 5 5 5 5 5 5 5 6 19 6 5 4 4 4 4 4 4 4 4 4 5 6 18 6 5 4 3 3 3 3 3 3 3 4 5 6 17 6 5 4 2 2 2 2 3 4 5 8 16 .. 6 5 1 1 2 3 4 5 6 15 6 1 2 3 4 5 6 14 1 2 3 4 5 8 13 2 2 3 4 5 6 12 3 3 3 4 5 6 11 4 4 4 5 6 10 5 5 5 5 6 9 6 6 6 6 6 8 7 Robot Definition 6 5 Speed [] 4 3 Fleld VIew [iJ 2 1 0 0123456 7 8 9 1011121314151617191920 21 22 23 24 25 2627 29 29 Figure 3.6 Test Case 1/Frame 2 Planning from Field of View Boundary ; Robot Pdth Gener11lor Simulillinn 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 0 Obstacle 0 Start Destination D Path Definition Speed [3] Fleld VIew GJ Figure 3. 7 Test Case 1/Frame 3 Final Path 25
PAGE 31
In the second simulation a robot is placed on location (1,0). This robot can travel faster than the robot in the first simulation --three cell locations in a single time interval. The field of view for the robot is modified to only three omni-directional increments. With this combination of speed and field of view, the robot must replan at the conclusion of every move. The destination location chosen for this robot is the last cell of the work area, (29,29). The time required to travel a shortest trajectory in this scenario is 10 time intervals. In the figures below, the progression of planning trajectories and movement along those trajectories is illustrated. f:. Robot Path Generator Simulation 1 2 3 1 0 9 8 7 6 5 4 3 2 3if!i3 3 1 __ 1 0 0 1 2 3 4 5 6 7 8 9 101112131415161118192021 222324 252627 2829 0 Obstacle 0 Start @ Destination 181 Path Definition Speed Field VIew [] Figure 3.8 Test Case 2/Frame 1 Planning from initial location 26
PAGE 33
v: Robol Pnlh Generalor Simulalion .. 4 3 2 1 0 9 8 7 6 5 4 3 2 0 0 Obatadc 0 Start Destination l8l Path DiGrili: Robot Definition Speed GJ Fleld VIew [] Figure 3.9 Test Case 2/Frame 2 Last Planning Stage from Field of View Boundary Robot Path Generator Simul a tion 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 1-o:;--;,-=-2 -=3:-:-4 -=s-=-s -=1-=-a 0 Obstade 0 Start @ Destination 0 Grid Definition Speed [] Flcld VIew [] Figure 3.10 Test Case 2/Frame 3 Final Path 27
PAGE 34
3.3 ROBar PATH PI...A.'lNING IN A."' ENVIRONMENT WITH OBSTACLES Almost every non-trivial application of this technology contain territories that a robot must be capable of avoiding. A mobile robot navigation scenario that omits the possibility of obstacles is unrealistic. Obstacles can be static, i.e. they are placed in the environment in given locations and stay in those locations for the duration. The robot can detect the presence of obstacles only within its sensor capabilities, defmed by the field of view. A variation on this theme is obstacles that are invisible to the robot until it encounters them in the process of moving along a path. This situation may be due to faulty sensors on the robot that initially failed to detect the blockage. It could also be the result of one set of obstacles obscuring another, preventing sensor readings. Whatever the reason, a robot may encounter, and must plan for, undetected impediments within the field of view. This section applies static obstacles to the implementation. Mobile obstacles are elements that are capable of movement. These can be other robots, vehicles, people, etc. that interact within the work area in a very dynamic fashion. This modification is applied in the next section. We provide an additional capability to the robot to work within the static obstacle environment. If the robot is unable to "see" the extent of the obscura within the assigned field of view, it is allowed to expand that view until a path is located. This is analogous to a robot possessing a variable sensor capability. Under most situations, a sensor that provides a limited view of the area is desirable. This capability uses less resources, provides for faster movement, etc. In certain situations, however, the robot must select a high performance sensor to examine a larger extent. While this may cost the robot in resources and time, it eliminates guess-work on the part of the robot as to the most optimal path. A guess made by the robot could potentially be much more costly than utilizing the more resource expensive sensor. Key to the introduction of obstacles to this environment is the possibility that an optimal path is not attainable. The Linguistic Geometry model generates optimal and non-optimal paths with a new paradigm .. the Language of Admissible Trajectories [Stilrnan, 1993]. 28
PAGE 35
3.3.1 A Language of Admissible Trajectories Assume a robot has determined through the language of shortest trajectories that an optimal path to a destination is not possible due to obstacles. In these circumstances the robot must have the means to plan a path to the destination along a longer, less optimal trajectory. Table 3.1 is a presentation of the programmed Grammar Gt<2l of Shortest and Admissible Trajectories. L 1 2i 3i 4 5 Table 3.1 Grammar of Shortest and Admissible Trajectories Q Q1 Q2 Q3 Q4 Q5 Vr ={a}, VN = {S,A}, VPR = Kernel, n., On S(x,y A(x,y ,1) A(x,y,l) mecL (x,y,l), lmecL (x,y,l)) A(mecL (x,y,l), y, 1lmecL (x,y,l)) A(x,y,l) A(x,y,l) A(x,y,l) Pred = {Q1, Q2, Q3, Q4, Q5} Q 1(x,y,l) = CMAPx.p(y) 1 < 2 X MAPx.p(y)) A (1 < 2n) Q2(x,y,l) = (MAPx,p(y) :1; 1) Q3(x,y,l) = (MAPx,p(y) = l) A (1 1) Q4(y) = (y = yo) Q5(y) = (y :t; yo) Var = {x, y, 1} 29 FT FF two 0 three three three 4 three 5 three 0
PAGE 36
Con = {xo, yo, lo, p} Func = Fcon U Fvar Fcon = {f, next1, next2, ... nextn, med1, meru, ... medn, lmed1, lmeru, ... lmedn} (n= I X I), fO) = l 1, D(f) = z. \ {0} Fvar = {xo, yo, lo, p} E = Z+ U X U P is the subject domain; Parm: At the beginning of the derivation: x=xo; y=yo; l=lo; xo, yo E X; lo E Z+; p E P. For this language, two new functions were created (in addition to the next function, a carry over from the language of shortest trajectories). They are defmed as: med.; (x, y, I) Domain: X x X x Z+ x P Define a set: DOCK(x) = {v I v from X, MAPxo,p (v) + MAPy0,p (v) = I} if DOCK.i (x) = {v1, V2, va, ... vm} != 0 then med.; (x, y, I)= Vi for 1 i m else medi (x, y, I)= x end if 30 The DOCK set is not empty med returns a unique DOCK point for each reference DOCK is empty robot stays at x position
PAGE 37
lmed. (x, y, l) Domain: X X X X Z+ X p lmed. (x, y, l) = :MAPx.p (med. (x, y, l)) :MAP distance from x to y The Language of Shortest and Admissible Trajectories extends the Language of Shortest Trajectories into an algorithm that allows the consideration of less than optimal paths. The thrust of this new grammar is to identify cells in the work area that serve as intermediate points accessible on shortest paths from the start location and the destination location. These DOCK cells are not necessarily on a shortest path. That is, they are not elements of the SUM set. Graphically, this can be depicted as the combination of two shortest trajectories as shown in the figure below. Destin Common Between 2 Shortest Trajectories Figure 3.11 Two Shortest Trajectories combined to Form a Non-Optimal Trajectory It is important to note that shortest trajectories are also promulgated from this language. Thus, if a shortest trajectory does exist, then it will be generated from this grammar. In this instance, the length is the shortest distance between locations and the DOCK set and the SUM set are equivalent. If optimal trajectories are not spawned due to obstructions, the length between two locations is longer and less direct derivations are attempted. 31
PAGE 38
3.3.2 Design Augmentation The basic objects described in the simple model also exist in this design, although they must be modified to accommodate the new environment. A new object, obstacle, is introduced that describes the areas on the work area where a robot can not occupy or travel through. Methods will undergo modification as the planning strategy now allows the possibility that a path is not achievable for a particular distance. In summary, the algorithm is modified to consider different levels of trajectories. 3.3.3 Objects Map The Map object represents distance from a location in the work area to any other location. In the previous manifestation of the design, we introduced the concepts of a static map and a dynamic map. With the introduction of obstacles, the distances represented by the static map are no longer accurate. Indeed, a given location on the map may not be reachable at all. The static map was a relative mapping independent of absolute coordinate assignment. Since the obstacles are absolute objects, the static map can not incorporate this knowledge into the database. Early designs attempted to work around this restriction by incorporating the obstacle knowledge into the planning algorithm instead of the map. In experimental testing, these designs proved to be easily defeated by non-trivial obstacle patterns. An accurate local distance map proved to be a critical feature of a good design. The dynamic map object calculates distances in real-time based on the state of the work area within the robot field of view. A list is formulated in the following manner. Working in a radial fashion outward from the current robot location, a Map is formed by considering simply what is "adjacently reachable" from a given location. Adjacently reachable is: the set of locations exactly one cell away from the current location that do not contain obstacles. These locations are tagged with the current distance and are added to the list to be considered in the next expansion. When the field of view is reached, the algorithm completes, leaving in its wake a calculated true distance for each cell. 32
PAGE 39
A form of a static Map object must also be retained to reflect distances of locations outside the field of view. The object is needed because the robot requires some knowledge of distances to locations outside the sensor range, such as fmal destination locations. This knowledge is incomplete since the robot has no indication of obscura outside the field of view that would affect distance. It can be used, however, to rate the path potential of a cell relative to another cell within the field of view. In this manifestation of the design, the static Map will be similar to the dynamic distance calculation presented in simple model. The algorithm will incorporate knowledge of the local distances into the calculation to obtain the most accurate total distance possible. Obstacle The obstacle object manifests itself in the design as state of a cell, a single atomic component of the work area. In the previous implementation, a cell contained a static structure for location as well as dynamic information describing any path infonnation (descendants and ancestors) that passed through the cell. In the modified design, we add a dynamic feature that allows the cell to be flagged to contain an obstacle. 3. 3. 3. 1 Methods Calculate Distance Using the radial technique described in the above Map object, this method calculates a true (dynamic) distance for all locations within the robot field of view. The algorithm considers current obstacle configuration. As an artifact of this algorithm, a parent relationship is established between cells in the field of view. This is done to facilitate trajectory generation in the path planning phase. The method also retains the capability to calculate static distances to those locations outside the field of view. The static algorithm factor local obstacle interference into the computation, however, it can not take into consideration obstacle interaction external of the robot sensor range. 33
PAGE 40
Generate Transition Locations This method produces intermediate locations that are within the current field of view for the robot and are also on the most optimal path to the fmal destination. The algorithm executed here is similar to the technique used to generate DOCK locations in the grammar of admissible trajectories. The method makes use of the true distances to the boundary locations to determine which of the cells have the greatest potential for expansion to the fmal destination. The algorithm adds dynamic Map distances to the transitional locations and the static Map distances from the transitional locations to the fmal destination. The smallest of the sums point to the most promising transitional locations to expand. If all of the boundary locations have potential that is less than the current location, then the path planning algorithm will simply plan to all boundary locations. This describes an environment in which the obscura is extensive enough that the robot can not usee" around it with the assigned field of view In such situations, the move method will invoke special processing to compensate. Plan a Path In this implementation, the plan is produced by formulating paths from the start location to the best transitional locations. Thus, the method uses the two algorithms described above to generate the dynamic Map and the optimal transition locations. Using the parent relationship established when the dynamic map was produced, this algorithm works backwards from the optimal transition locations to the parent cells. The parent cells are expanded to their ancestors, and so on until the start location is reached. This forms the trajectories on which the robot will travel. Execute a Path In the absence of obstacles, this method simply moved the robot on a pre-planned trajectory until it reached the end of the field of the view or reached the fmal destination. If the destination was not attained, the algorithm would kick-off another planning session. With the advent of obstacles, in particular the so-called invisible obstacles, this method looks ahead at each cell along the trajectory to ascertain if that cell contains a hidden obstacle. If all cells are blocked on the planned path, then the method must formulate new trajectories from the current location by calling the planning method. 34
PAGE 41
The move algorithm must also invoke special processing in case the obstacle layout prevents the robot from determining the best course. The processing is energized by a message from the planning algorithm that all boundary location potentials are worse than the starting location. In this situation, the robot will expand the field of view from the nominal state provided at robot creation. Mter each expansion, the planning algorithm is invoked to determine the potential of the new boundary locations. Once the potential exceeds that of the start location, the robot begins movement on the planned trajectories. The field of view is reset to nominal state. Finally, this method plans after every full robot movement. This is done to take advantage of the gain in the field of view attained whenever the robot moves. Experimentally, it was determined that this permitted the robot to see blind alleys earlier in the path than if the robot simply followed the older trajectories 3.3.3.2 Classes The attributes and methods of the augmented robot control design are compiled into the classes illustrated below. The robot simulator now updates obstacle locations with a set/reset obstacle location message to the Area Map. A new message from Robot to the Area Map allows the robot to inquire about obstacle presence at a given location. Existing methods and attributes were modified as described in the above discussion. 35
PAGE 42
Create ROBOT SIMI. J LATOR Obstacle Location Updates "'llr "'llr ExecutA Get Path Info CreatE De AREA MAP Move lete ... "'llr "'llr Clear Path ROBOT Link Cells Calculate Distance Generate Transition Locatic p Set/Reset Obstacle t.. Reset Path Plan a Path RonnPt ()hat.,,.]., n. I" Execute Move Link Cells Absolute Area I" Return Path Information Area Size t.. rAJt"uJAto niatAn,... I" l..l o .... I"V ()hat .... l .. n Area Map Speed Field of View Graph Start Current Graph DestinatiorLocation Last Location Figure 3 .12 Class Diagram of Robot Software in Static Obstacle Environment A state diagram presented below demonstrates the planning and movement state transitions performed within the robot class 36
PAGE 43
Initialization From Robot Sim. ,, Initialize Local Attributes Path Planning Existing Path Info. ,, Generate Transition Locations ,, Generate Admissible Trajectories Path Execution Move on Trajectory To Path Planning No Done -------1 Figure 3.13 Planning and Path Execution State Diagram The start-up scenario is similar to what was presented earlier. On startup, a creation message is sent to Area Map providing the user-defmed size of the work area. Using the Robot simulator, a user selects a starting location and a destination location for a robot. The user also supplies the functional capabilities of the robot: speed and field of view. The robot simulator sends a create message to a Robot providing an Area Map object as well as the speed, field of view. The user controls the movement of the robot from the simulator. Based on the field of view distance, the robot builds a network of trajectories from the start (current) cell to the selected transition cells. The network is fashioned by the planning algorithm. Motion is generated along one of the planned trajectories. The move process is repeated until the current location is the destination cell or the field of view limit is reached. The Execute Move method with automatically re-task the planning algorithm when the robot reaches a field of view boundary, or an invisible obstacle prevents further movement. The Execute Move method also invokes changes to the field of view as described in the above discussion. 37
PAGE 44
3.3.4 Test Results Experimental results are presented in three sets of test cases. The first simulation places the robot into an environment with numerous, overlapping walls. The second simulation requires that the robot plan to exit a room and gain entry to a room in order to reach the destination. The final test case introduces invisible obstacles. These are blockage that are not perceived by the robot until it is close to the obstacle. 38
PAGE 45
3.3.4.1 "Walls" Scenario The start and destination location are located on opposite sides of the work area: location (0,16) and location (26,10) respectively. The robot is created with a velocity of 3 cells per time interval with a field of view of 6 cells in all directions. In the initial frame, figure 3.14, the planning algorithm identifies three optimal boundary locations (4,22) at a distance of 6 from the start location, (6, 11) at a distance of 8 and (6, 10) also at a distance of 8. Note that the distances labels on the far side of the obstacle reflect actual travel time required to reach the cells and not a straight line distance. Also note that the boundary locations directly in front of the robot are rejected by the planning algorithm due to local blockage. Thus, the robot seeks a route around the obstacle with the planned trajectories. j Robot Path Generator I I 9 B 7 6 5 4 3 r:i .,o,........,..t -:2-3:---:-4-:5:-::-6 -=7,...8,.......,.9...,..1 -:-::17,...,.1 3 2 I 0 0 Obstacle 0 Start Destination 181 Path 0 Grid Robot Definition Speed [] FleldVIew Figure 3.14 Test Case 4/Frame 1 Initial Planning and Motion 39
PAGE 46
In the second frame, figure 3.1.5, the robot has completed its fourth time interval. At location (10,10), it has cleared the first two walls and successfully planned around a third. The move execution algorithm has selected a more satisfactory route based on better proximity to a (theoretical) straight line path to the destination. ; Robot Path Generator Simulation I I 9 II 7 6 s 4 3 2 l: 1 0 9 II 7 6 s 4 3 2 1 1-,0::--:-1 """2,......,....3 ....,.4....,5:--:-6 -:7,..-B:--:-9 ...,.1 0""'1'"'"1 "'"'12:-:-1-::-3 1:-:-4-:-:15:-:176 1:-::7""'"'1 B::-:179 20=-::-21'""'22=23'""2"'"'4 25=26:-:2-::-7 O 0 Obetede 0 Start Destination l8l Path .. Robol DeHniUon Speed [2] FleldVIew Figure 3.15 Test Case 4/Frame 2 Fourth Time Interval The next frame, figure 3.16, illustrates the robot situation at time interval 6. The planning algorithm has selected three optimal boundary locations: (18,14), (18,13), and (17,6). Once again the robot selects the northern route, demonstrated in figure 3.17. At this stage, time = 10, the destination is within the field of view and thus is the only identified transition location. The fmal frame illustrates the as-executed path for this scenario. The robot reached the destination in 12 time intervals, traveling over 36 cells. Without the blockage, the robot would have required 9 time intervals, traveling over 26 cells. 40
PAGE 47
Robot Path Simulation 29 29 27 26 .... 111111 23 22 21 20 19 18 17 16 15 14 13 12 r:11 10 9 8 7 6 5 4 3 2 1 0 0 Obstade 0 Start Destination 0 Grid Robot Definition Speed [iJ Fleld VIew [iJ Figure 3.16 Test Case 4/Frame 3 Sixth Time Interval ; Robot Path Generator Simulillion 0 Obatacle 0 Start Destination D Grid -Definition Speed [] FleldVIew Figure 3. 17 Test Case 4/Frame 4 Final Planning Stage 41
PAGE 48
. Robol Palh Generalor Simulation I I 0 Obstade 0 Start Deatlnadon 0 Path .. Robot Definition Speed [] Fleld VIew [U Figure 3.18 Test Case 4/Frame 5 As Executed Path Display 42
PAGE 49
The next "walls" scenario demonstrates the effect of local blockage on the overall path chosen by the robot. In this experiment, the start location is moved up one cell to (0, 17), while the destination remains at location (26, 10). The obstacle locations are also unchanged. With the one cell change to the start location, the planning algorithm initiates a completely different plan than in the previous scenario. A single transition location was determined to be optimal: (5,23). This boundary location is six cells from the start location and offers the greatest potential. The cells selected in the previous scenario, below the initial location are either blocked (5, 12) or proffer a worse potential (3, 11) than (5,23). , 1 Robot Path Generdlor Sirnulatinn 4 3 4 2 3 4 1 2 3 4 1 1 2 3 4 2 2 2 3 4 3 3 3 3 4 4 4 4 4 4 5 5 5 5 5 8 8 8 8 I .. I r: ...,o:--:-1 -=2,.......,...3 ""'4""'5=--=-s -=7:-e:--::-s-:-1 -=-o 1:-:-1 ""1 2,....,1.,.31.,...,4....,1 s::-:1'-="s "'"'11,...,.1 ==2s=-=2:-:8 21=2e=-=29= 4 3 2 1 0 0 Obstacle 0 Start Deatlnatlon 0 Grid Robot Definition Speed [] AeldVIew Figure 3.19 Test Case 5/Frame 1 Initial Planning and Motion In the second frame, the robot is well into the scenariO. The robot has the destination in the field of view but can not reach it. The fmal frame illustrates the as executed path for this scenario. 43
PAGE 50
Robot P111h Generator Simul111ion [.?,r:J I 7 7 7 7 7 s s 6 8 6 5 5 5 5 6 4 4 5 8 3 3 4 5 6 4 56 58 I'VII>""""OVO.. 5 6 s .. I 1 0 Obltade 0 Start Destination DiGrf.t: -Definition Speed GJ AeldVIew @] Figure 3.20 Test Case 5/Frame 2 Destination in Field of View and Not Reachable { Robot Path Generator Simulation I 1 0 9 8 7 6 5 4 3 2 1 0 0 Obstacle 0 Start Destination 0 Path -Definition Speed Aeld VIew [iJ Figure 3.21 Test Case 5/Frame 3 As Executed Path Display 44
PAGE 51
The next Mwalls" scenario fmds the robot trapped behind a obstacle that it is unable to plan around given a nominal, omni-directional field of view of 6 cells. The robot applies extra resources and expands the field of view to 7 cells to permit planning to a cell of greater potential than the initial location. ;;,'j Robot Path Generator Simulation 7 7 7 6 8 6 5 5/l>
PAGE 52
' : Robot Path Generator Simulation 5 ' ' 5 6 5 4 3 3 3 3 3 3 4 5 6 5 3 2 2 2 2 s 6 543211 6 5 3 2 5 4 3 5 4 3 3 5 4 4 5 5 s s 6 6 6 6 7 7 7 7 I I 0 Obstade 0 Start Destination 181 Path 0 G rid Definitio n Speed FJeld VIew [] Figure 3.23 Test Case 6/Frame 2 Reestablish Original Field of View Robot Path Generator Simulation 0 Obstade 0 Start Destlnadon 0 Grid Robot DeflnltJon Speed GJ FleldVIew Figure 3 24 Test Case 6/Frame 3 As Executed Path Display 46
PAGE 53
3.3.4.2 "Rooms" Scenario The next set of scenarios require the robot to navigate out of room with only one exit and process to a destination in another room with only one entrance. In the fust experiment the robot is given a speed of 2 and a field of view of 5 cells in all directions. The robot is placed at an initial position of (13,4), while the selected destination is assigned to (8,26). Note from figure 3.25 that both the initial robot location and the destination are placed inside of confmed areas that the robot must plan around in order to accomplish its goal. In the initial plan, illustrated in figure 3.25, the planning algorithm immediately plans a route out of the room. All paths are directed to the left of the initial location because the field of view restricts the robots view of what is outside the far right wall of the room. The algorithm did not require an expansion of the field of view for its initial planning. ;/;, Robol Palh Gencralor Simulation tac I ...... 1--11. 15 1514 15141 I I 5.1 4.1 0 1 2 3 4 5 6 7 8 g 10 .. .., 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 0 Obstacle 0 Start @ Destination 181 Path 0 Grid Robot Definition Speed [?] Field VIew [D Figure 3.25 Test Case 7/Frame 1 Initial Planning and Motion The robots second advance, presented in the second frame (figure 3.26), shows the effect of re-planning each motion. The robot, now capable of seeing outside the right 47
PAGE 54
wall of the room now rejects the original transition locations and paths to the left of the room as being less satisfactory than those to the right. Basically, these new trajectories avoid traveling the length of the bottom wall of the room in order to clear the obstruction. c 0 Obetacle 0 Start P.. Destination I I l8l Path Di'Grl.ii 9 I I B 7 6 -I I 5 4 3 2 L II 1 0 9 e 16161616161514131 7 Robot DeflnHion 1515151 6 141414 s Speed [] 131313 4 121212 3 Field VIew [] 121111 2 1211 1 12,11 0 Figure 3.26 Test Case 7/Frame 2 Improve Path after First Motion By the third frame, the robot has successfully navigated the obstacles to fmd the destination in the field of view. It can not, however, map a path to the destination due to obscura. In order to improve the path potential relative to the current location, the planning algorithm expands the field of view from 5 to 6 cells. Note that the entrance to the room containing the destination (4,28) is now within the field of view of the robot and a trajectory is generated to the destination. This is illustrated in the fourth frame, figure 3.28. The fmal frame, figure 3.29, presents the as-executed robot path for this experiment. The robot navigated through the obstacles through 47 cells in 24 time intervals. 48
PAGE 55
' Robol P111h Generalor Simulalion I I I .. 9 e 7 6 5 4 J 2 1 0 9 e 7 6 5 4 3 2 1 0 0 Obstacle 0 Start DuUnaUon 1:8:1 Path Robot Definition Speed [] Field VIew 5J Figure 3.27 Test Case 7/Frame 3 Approach Task Destination Robot P111h Gener111or Simul>tlion J-0::-:-1-2::::-::3-4-:-::5:---=-6 -=1:---=-a 9 8 7 8 5 4 J 2 1 0 9 8 7 6 5 4 J 2 1 0 0 Obstacle 0 Start Destination 1:8:1 Path Definition Speed [] Flcld VIew 5J Figure 3.28 Test Case 7/Frame 4 Plan to Entrance to Room 49
PAGE 56
I I I I Robol Palh Generalur Simulallon J 0 Obstacle 0 Start DuUnatlon 0 Patti Robot Definition Speed [] FleldVIew t:0::--:-1 -::2:-3::--:-4-:5:--::-8 -::7:-a::--::-9-:-1 S:-:1-::-81':":7::-1 9 a 7 6 5 4 3 2 1 0 9 a 7 8 s 4 3 2 1 0 Figure 3.29 Test Case 7/Frame 5 As Executed Path Display The second "room" scenario greatly increases the complexity of the domain. In this scenario, the robot must first exit a room and then navigate through a maze of rooms to finally attain the destination. The robot retains the characteristics of the previous experiment: a velocity of 2 cells per time interval and a field of view of 5 cells in all directions. The initial location of the robot is placed at (24,20) and the destination is selected at (2,29). In the first step, the robot must expand the field of view (to 7 cells) just to locate transition locations that get the robot into a greater potential than the initial location. This expansion is depicted in frame 1, figure 3.30. The second frame (figure 3.31) shows the robot heading for the "room maze" with a trajectory through the entrance. .50
PAGE 57
252525252525252525252526 24 24 24 24 24 24 24 24 24 24 25 26 23 23 23 23 23 23 23 23 23 24 25 26 222222 222222 22 22 23 24 25 26 212121212121 20 20 20 20 ....... 9191919 61618 717 20 1 0 9 8 7 6 5 4 J 2 1 o::--:-1--=-2 -:3,....-,-4 --=s:-:-s --=1:-:-e --=9:-1:-::0-:-11,....1=-=2-:-1 3""1""'4..,., 0 Obstade 0 Stan Destination I8J Path 0 Grid": .. Robot Deflnillon Speed [U FleldVIew Figure 3. 30 Test Case 8/Frame 1 Initial Planning and Motion 0 Obstade 0 Stan Destination l8l Path 0 Grid Robot Deflnillon Speed [3] FleldVIew Figure 3.31 Test case 8/Frame 2 Find Entrance to Room 51
PAGE 58
The third frame (figure 3.32) depicts an interesting robot plan. The planning algorithm formulated a trajectory to location (5,21) in an attempt to gain access to the destination from the south (0 .. 4, 21). Frame four illustrates how on the next plan the algorithm rejects this solution and instead expands the field of view to 8. This permits access to the destination location, a path in which the robot follows to complete its goal (figure 3.34). From location (6,20) the robot would have attained a more direct path to the destination through (6,21) than though (5,20). The attempt to gain access to the destination generated a one cell perturbation towards the fmal destination. Of course, the perturbation confirmed that a more direct route was not possible. 9 8 7 6 5 4 3 2 0 5 6 7 8 9 1011121314151617181920 0 Obstade 0 Start @ Destination [81 Path 0 Grid Robot Definition Speed EJ Field VIew Figure 3.32 Test Case 8/Frame 3 Direct Route is Blocked 52
PAGE 59
0 Obstade 0 Start Destination 0 Grid Robot DeHnltlon Speed [U Field VIew EJ Figure 3. 33 Test Case 8/Frame 4 Expand Field of View to Destination 9 8 7 6 s 4 J 2 1 0 Obstacle 0 Start Destination D Path Robot Definition Speed [] Field VIew GJ Figure 3.34 Test Case 8/Frame 5 As Executed Path Display 53
PAGE 60
3.3.4.3 Invisible Obstacles Scenario The fmal experiment for static obstacles leverages off of the previous scenario. In this version, however, we introduce the so-called uinvisible" obstacles into the environment. Recall that these obstacles are not detected in the planning phase and can be encountered blocking planned trajectories. The movement generation algorithm must detect this unplanned obscura and if necessary, replan around it. The robot path display simulates invisible obstacles by supporting the placement of obscura while the robot is in the process of planning and moving. The initial state of this scenario was precisely as it was in the previous experiment. In the first frame (figure 3.35), the robot is 7 steps into the plan when, from the robot simulator, new obstacles are defmed in rows 19 and 21 as noted on the graph. The robot executes two more time steps of the current plan before realizing that the trajectories are now blocked. The second and third frames of the scenario depict the next two time intervals of the experiment and demonstrate the perturbations introduced by the new obstacles. Frame 2 shows the robot, with a nominal field of view, attempting to bypass the invisible obstacles to the left. Frame 3 shows that after movement along that trajectory, the robot can not improve its position any further and expands the field of view allowing navigation through the invisible obstacles. The remainder of the scenario is similar to the previous presentation. 54
PAGE 61
Invisible Obstacles 25 25 25 25 25 25 25 25 25 25 25 26 24 24 24 24 24 24 24 24 24 24 25 26 23 23 23 23 23 23 23 23 23 24 25 26 22 22 22 22 22 2222 22 23 24 25 26 21 21 21 21 1 0 9 8 7 6 5 4 3 2 1 0 Start 0 Destination t8l Path .. .. 0 Grid Definition Speed AeldVIew Figure 3.35 Test Case 9/Frame 1 Invisible Obstacles Placed in Area 9 8 7 6 5 4 3 2 1 0 Obstacle 0 Start 0 Destination I8J Path Definition Speed [!] FleldVIew Figure 3.36 Test Case 9/Frame 2 Plan Rejects Route to Destination 55
PAGE 62
5 4 5 4 5 J J J J J 4 5 4 4 4 4 4 4 5 5 5 5 5 5 5 5 5 5 5 5 6 6 6 6 6 6 6 6 6 6 6 10 9 8 7 7 7 7 7 7 7 7 7 7 7 7 7 10 9 B 8 8 8 El El B B El 8 B El El B 10 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 10 101010101010101010101010101010101010101010 Obstacle 0 Start 0 Desdnatlon 0 Grid Robot Definition Speed [U Field VIew GJ Figure 3.37 Test Case 9/Frame 3 Plan Around Invisible Obstacles 56
PAGE 63
3.4. RoBar PATH PLANNING WITH STATIC AND DYNAMIC OBSTACLES Additional mobile elements are introduced to the environment in this section. In general, mobile elements can relate to our robot in several different ways. They may be of an adversarial nature, attacking the robot in an attempt to capture or destroy. Mobile elements may also be cooperating systems working on the same or different tasks. The last category, dynamic obstacles, is the type of system we will introduce to our environment. Mobile elements of this type simulate several different reallife situations encountered by a task oriented robot. In a factory oriented application, obstacles represent mobile equipment, people, or other robotic systems. In a space based application, mobile obstacles might represent satellites operating in the same area. These systems are not inherently opposed to the robot, i.e. they do not directly attack. They do, however, occupy space, and move concurrently within the same area as the robot. Similar to the static obstacle scenarios, the robot must avoid the moving impediments in the process of completing a task as quickly as possible. The planning problem is made more difficult by the mobile nature of the obscura. Since the obstacles move concurrently with the robot, the planning algorithm must consider how each obstacle travels during a given time interval as well as the starting and destination cells. That is, the robot must account for the route taken by mobile obstacles. Before presenting the robot system response to this environment, it is important to defme the behavior of the dynamic obstacles used in the model. The obstacles may be of any shape and size that can be practically contained in the work area. Similar to the robot, they are assigned a velocity describing how fast and far they may move in a single time interval. Mobile obstacles are assigned an "area of operation". Their movement is restricted to this area. When any portion of a mobile obstacle attempts to move outside the designated area of operation, it will change direction and move back into the area. Mobile obstacles are allowed to occupy the same space as other mobile obstacles and static obstacles without affecting movement. The robot must also follow certain rules for interaction within the new environment. Similar to the static obstacle scenario, the robot can only consider dynamic obstacles that are inside the field of view. Moreover, if only a part of a dynamic obstacle is within 57
PAGE 64
the field of view, the robot may only consider that portion of the obscura Obviously, the robot can not coexist in the same location as a dynamic obstacle Because of concurrent movement the robot can not travel over the same route taken by a dynamic obstacle to reach its new location in the same time interval The route is inclusive of the starting locations of the dynamic obstacle. Two examples shown below demonstrate legal and illegal movement on the part of the robot In both examples the obstacle is moving two cells in the y direction as indicated by the arrows emanating from the obstacles in the figure. This makes the cell directly under the current robot location inaccessible. Legal Movement Illegal Movement Figure 3 38 Examples of legal robot movement and illegal robot movement To accommodate a dynamic environment the planning algorithm must consider current and future interaction between trajectories and moving obstacles. The Linguistic Geometry model provides a set of tools for this paradigm 58
PAGE 65
3.4.1. Trajectory Networks So far in the exploration of Linguistic Geometry we have derived tools for expressing the movement of a single element in a system. This is a lower level operation that does not necessarily provide system level solutions. Tools are required to express the interaction between multiple agents in the system. This is the basis for breaking down a system into smaller subsystems. The subsystems in this case are the inter-connected trajectory networks formed by the movement activity of elements in an area. The elements may be attempting to accomplish a goal, preventing an element from accomplishing a goal, or supporting an element. The general idea for network generation will be demonstrated with the scenario in figure 3. 39. (2,2) (4,4) (3,3) Figure 3.39 Trajectory Network Example Element Po is planning to move along trajectory (1, 1), (2,2), (3,3), (4,4) to reach a goal destination of (5,5). Element Qo and Q1 are opposed to this activity and can intercept the Po trajectory at (3,3) and (4,4) respectively. Elements Pl and P2 support the goal and can inhibit the interception of Po by controlling locations along the Qo and Q1 trajectories. We state that a trajectory connection relation, C(t1, t2), exists between two trajectories if the end link of t1 coincides with an intermediate link of t2. In the above example the Q1 and Po trajectories are connected at (4,4). The connectivity relation can be indirect also. The Pt and Po trajectories can be considered connected through the Q1 trajectory. This is considered a degree 2 connection since it is not a direct connection to the main trajectory but it is part of the network that will determine 59
PAGE 66
whether Po can complete its goal. The degree of the connection is determined by how far the trajectory is removed from the main trajectory. The Qo trajectory is attempting to control a location along the main trajectory, therefore. it is a degree 1 relation to the main trajectory. We formally describe a trajectory network,W, relative to a trajectory to as a fmite set of trajectories to, t1, ... tk from the language LtH(S) (Language of Trajectories) that have the following property. For every trajectory from W there is transitive closure to the main trajectory. That is, each trajectory from the network W is connected to to [Stilman, 1996]. A family of trajectory network languages Lc(S) in a state S of a complex system defmition is the family of languages that produce strings of the form: t(to, param)t(t1, param) ... t(tm, param) where param is defmed by the specific parameters of the language. The strings produced by a network language should look vaguely familiar since they roughly resemble the strings produced by the Language of Trajectories. In the same way that trajectory languages describe one dimensional objects in a system by forming a string of symbols based on a reachability relation, a network language describes higher level objects using the trajectory connection relation [Stilman, 1996]. Different grammars can be generated from this family of languages that correspond to a particular solution. One grammar, Zones (Gz), is particularly useful in describing systems similar to our path planning problem. The detailed derivation of this grammar can be found in [Stilman, 1993]. It will serve here informally as the theoretical basis for a solution to a dynamic obstacle environment. A Language of Zones produces strings of the type: t(po,to, 'to)t(p 1, t1, 'tt) ... t(pk, tk,'tJ where p represents the elements and t represents the trajectories of those elements. represents the time allocated for motion along the trajectory to either intercept or support the main trajectory. If the length of the trajectory is greater than the amount of time available to affect the main trajectory, then that trajectory can be eliminated from consideration. In our system, the goal is roughly the same to avoid intercepting elements (dynamic obstacles) in the process of accomplishing a task. There are not, 60
PAGE 67
however, supporting elements to block the interceptors. In contrast to the more adversarial environments, dynamic obstacles will simply pass through a particular interception point on the main trajectory and will generally not wait to attack the robot. The concept of incorporating a time that intercepting trajectories may affect the main trajectory will play an important role in the software design. The implementation of this concept is detailed in the following section. 3.4.2. Design Augmentation The basic objects described in earlier presentations also apply to this environment. Several objects and methods will undergo significant modification to accommodate defining and generating motion for dynamic obstacles. In general, the robot software must respond to a much more dynamic environment than in previous implementations. The planning algorithm will incorporate predictions of where dynamic obstacles will be in future time intervals. This data affects which transition locations and trajectories are admissible. The movement algorithm will also incorporate current dynamic obstacle activity to avoid collisions and institute new planning when required. The following sections details additional objects and methods and changes to existing objects and methods. 3.4.2.1. ()bjects ()bstacle This object, in the previous design a simple indicator describing the state of a cell, must now be expanded to engender movement. Obstacle now defmes a group of obstacles that share common movement criteria. From time interval to time interval, the locations that the obstacles occupy changes, thus changing the state of the cells at those locations. All state changes to cells are communicated through the Map object so there is one repository for work area cell status. Obstacle contains several attributes that describe the initial state of the group. This includes: starting locations of the obstacles, the amount of movement allowed in the x and in the y direction, and the allowable area of movement (min/max x, min/max y). Additional attributes describe the dynamic state of group: current location of the group members, current direction in x 61
PAGE 68
andy, and the set of locations that the obstacle traveled over in execution of the current time interval. 62
PAGE 69
3 4 2 .2. Methods Execute Obstacle Movement This is the first of two-step algorithm to engender movement for a dynamic obstacle. Obstacle movement is staged to simulate simultaneous movement of obstacles and robot. This stage of the algorithm executes prior to robot planning and movement in a given time interval and performs three basic functions. First, it determines, with the next application of movement criteria if any portion of the obstacle will fall outside the defmed area of movement. If it detects such a condition, it reverses the direction of movement in whichever coordinate is affected (x or y). The second function calculates for each member of the obstacle group, the intermediate locations over which the member will travel to reach its new destination These locations are identified to the Map object and are set to a special cell state indicating that an obstacle has moved over this area in the current time interval. Finally, this method calculates the fmal destination for this time interval for each member of the obstacle group These locations are also identified to the Map object to update the location of the obstacle on the map in second stage of the dynamic obstacle movement algorithm. Complete Obstacle Movement In the second stage of obstacle movement the object completes the movement cycle By this point the robot has completed its planning and movement for the given time interval. The obstacle is still on the map in its old location with the cells identified as to its new locations and the route it traveled to reach them. This method removes the obstacle tag from the old cells and resets indicators for the traveled upon intermediate locations. Finally, the new cell locations are tagged as containing obstacles. These rather complex steps create a facsimile of simultaneous movement to the robot. The same obstacles potentially shows up in several locations but with different state flags identifying old travel and new position The robot planning algorithm uses this information to plan its path accordingly. Calculate Distance 63
PAGE 70
The basic thrust of this method stays the same in this implementation. That is, at each time interval it dynamically calculates distances from the start location to all locations within the field of view. The algorithm must now consider the movement of dynamic obstacles in the current time interval when determining distance. A particular unblocked cell, adjacent to the start location, may not be assigned a distance value of 1. If a dynamic obstacle is moving into that cell at the current time, the distance value may incorporate robot movement around the obstacle. Alternatively, a cell that is currently blocked may have a distance assigned if it will be reachable when the dynamic obstacle leaves the cell. Predict Obstacle Location This new method predicts where blockage will occur in future time intervals. This data is incorporated into the trajectory forming phase of the planning algorithm. In general, a robot operating in this type of scenario must look at obstacle movement over time to ascertain the dynamic characteristics of the object. In this application, however, the robot is allowed to query any dynamic obstacle (through the Map object) in the field of view to get the velocity and the direction of obstacle movement. The robot does not know the area in which a given dynamic obstacle operates, nor does it know the complete geometry of the obstacle unless it is all contained in the field of view. With the knowledge it does possess, though, this algorithm computes a predicted location for each component of the obstacle group for robot distances as determined by the Calculate Distance method. This is accomplished using the following equations: Where: Predicted (x) = current (x) + (time direction (x) *velocity (x)) Predicted (y) =current (y) + (time direction (y) *velocity (y)) current(n) direction(n) velocity(n) time = n (x or y) coordinate of current location. =Direction of movement in n (I =forward -l=back, O=none). = Speed of obstacle in n coordinates. =Delta time from current. If a cell is predicted to contain an obstacle, a special flag is set in association with the time that an obstacle is expected to be at that cell. Plan a Path 64
PAGE 71
This method makes use of the distance information and the predicted obstacle location data to form trajectories that give the robot the best chance to optimize movement to the destination and to avoid colliding with obstacles. Recall from previous implementations that trajectories were formed by determining the best transition locations to the destination and then working back to the start location. The trajectory path links were established using the distance information for adjacent cells. This basic algorithm is retained in this implementation with added enhancements. The predicted obstacle data is used to determine if an obstacle trajectory will intercept a robot trajectory to a transition location. If this does occur, that path is eliminated from the set of possible moves. In certain circumstances, all paths to transition locations may be cut off. Here, there are still options. If available, it can construct a partial path on the way to a transition location and determine if a change in the field of view offers a better path. It may, if the robot is not in danger of having an obstacle collide with it, elect to stay at the current location until circumstances improve. We will discuss this method in some detail when we examine specific test cases. 3.4.2.3. Classes The attributes and methods of the augmented robot control design are compiled into the classes illustrated in figure 3.40. A new class is added, Obstacle, to defme a dynamic obstacle. It receives Create, Execute Move, and Complete Move messages from the robot simulator. It also registers itself with the Area Map class. When changes occur in obstacle location or direction, it sends Update messages to the Map. The Area Map class is modified to keep a list of dynamic obstacles in the current scenario. The Set/ Reset Obstacle method is modified to reflect many different states that are assigned to a cell: static obstacle, current dynamic obstacle, on path of dynamic obstacle, new dynamic obstacle, and predicted obstacle. It is renamed to Set Cell State. The Report Obstacle Presence method is now called Report Cell State. The Robot class is modified to send a Dynamic Obstacle Query message to the Area Map class to obtain data for those dynamic obstacles in the field of view. Robot also adds the ability to set the state of a cell to a predicted obstacle. 65
PAGE 72
ROBOT SIMULATOR Execu e Complete Set Cell Creau Create State Move Move (Static Obstacle) .. Execute Get Path Info CreatE Delete Register Dynamic AREA MAP Move Obstacle .. Clear Path r Update Dyn Link Cells Obstacle Calculate Distance Set Cell State Report Cell State Register Dynamic Obstacle Update Dynamic Obstacle Report Dynamic Obstacle Absolute Area Area Size Dynamic Obstacle List .. "'r .. II' .... .. .. T ROBOT OBSTACLE R-Pt PAth GenerateTransition Location Execute Move -l.inlc (CpiJ,. Plan a Path Complete Move Jn .. ta ....... Execute Move Reset To Initial State Return Path Information Quprv r. .. n StAte_ Initial Locations Set Cell State (Predicted Obstacle) Area Map Current Locations Query Dynamic Obstacle Speed Intermediate Locatiort Field of View Direction Graph Start Velocity Current Graph Area of Operation Destinatiod.ocation Area Mao Last Location Figure 3.40 Class Diagram 66
PAGE 73
3.4.3. Test Results Experimental results are presented in three sets of test cases with increasing complexity. The first simulation shows robot interaction with a single dynamic obstacle. This test will demonstrate the planning concepts discussed previously in an uncluttered environment. The second test case adds additional dynamic obstacles to the environment and examines robot response to more difficult situations. The fmal test case re-introduces static obstacles with more dynamic obstacles to create a very complex environment. The robot simulator display was modified slightly for dynamic obstacles. These obstacles are cast in a dark gray with black borders to help the user distinguish between the static and mobile obscura. 67
PAGE 74
3.4.3.1. Single Dynamic Obstacle Scenario In this initial example, one dynamic obstacle group is introduced into the environment. It is formed at locations {(2,25) through (6,25), (5,26), (5,24)} as illustrated in figure 3.41. The obstacle group is assigned a velocity of 2 cells in they direction and 0 cells in the x direction per time interval. The obstacle is allowed to range over the entire work area in the y coordinate system. So, in the first time interval the dynamic obstacle will move from its current locations through {(2,26) (6,26), (5,27), (5,25)} to a new set of locations: {(2,27) (6,27), (5,28), (5,26)}. The robot starts this scenario at location (3,27) with a task destination at the bottom of the work area at (3, 1). The robot field of view is 5 cells and its speed is 2. Notice that if the robot does not move in the first time interval, it will be struck by the dynamic obstacle moving into its current location. The robot also can not move into the locations directly below (3,27) since they are in the travel path of the dynamic obstacle. ; ;, Robot Path Generator Simulation f3f'-', .... 29 28 21 26 25 24 23 22 21 20 19 18 11 16 15 14 13 12 11 10 g 8 7 6 s 4 3 2 1 0 0 Obstacle 0 Start Destination I:Bl Path 0 Grid Robot Definition Speed (U Aeld VIew [ill Figure 3.41 Test Case 10/Frame 1 Initial Assignment 68
PAGE 75
In frame 2, figure 3.42, the robot has planned and executed its initial move. Carefully note how the robot planned its paths. Although the dynamic obstacle now obscures the initial location of the robot, the robot planned initial movement up from (3,27) to (2,28). This particular movement means the robot can avoid the initial dynamic obstacle movement and it apparently clears the robot from further interference from the obstacle on the next time interval. From (2,28), the planning algorithm identifies a lateral movement to (1,27) or down and over to (2,27). It may be odd to see a path planned through an obstacle, however, the dynamic nature of the obstacle means the planning algorithm can construct a path through an existing obstacle location with the understanding that the obstacle will not be in that location at a later time. So, with the assigned distance of 3 and a robot speed of 2, it is predicted that the obstacle will have vacated the (2,27) cell by the second time interval. The blank space in the field of view is the space just vacated by the obstacle. Recall that trajectory generation is not allowed in this area. ;': Rubol P11lh Gt:nerillor SirnuJ,Iiun g;'jp 3 2 2 2 2 2 3 4 5 32 11 345 3 4 5 5 5 s 6 6 8 7 7 7 7 e e e e e 9 9 9 .. 9 e 7 6 5 4 3 2 1 0 g 8 7 6 5 4 3 2 1 0 t.,o=--=-1 -:2"""'3=--=-4 -:s'""'e=--=-7 29-:: 0 Obstacle 0 Start Destination 181 Path 0 Grid Definition Speed [] FleldVIew Figure 3.42 Test Case 10/Frame 2 Initial Movement for Obstacle and Robot 69
PAGE 76
Frame 3 (figure 3.43) shows a dynamic obstacle changing direction. On this time interval a portion of the obstacle (5,28) would fall outside the work area if the delta y (2) was added. Therefore, the entire group changes direction and moves down the work area. The robot path planning reflects this new condition. Since the obstacle has changed direction and can match the speed of the robot, it will prevent the robot from planning a path inward on the work area lining itself up with the destination. ; . Robol Palh Gr:ner111or Simulalion 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 t.0::-:-1 -:2:-:;-3 -;4-:5;--;;-6 0:::-:1:-:-1 7::1 2:-:-1 O 0 Obstacle 0 Start @ Destination .. Robot Definition Speed FleldVlew Figure 3.43 Test Case 10/Frame 3 Obstacle Changes Direction Finally, in time interval 11 the robot has the destination location in the field of view and has planned a direct path to that location. The obstacle, illustrated in figure 3.44, will overlay the destination in the next time interval, preventing the robot from reaching that location. In this situation, if the robot is not in danger of being struck by the obstacle, it can simply wait for the obstacle to clear the area and then resume its path to the destination. This is illustrated in figure 3.45. This particular behavior is special processing added to the movement generation method as a result of problems discovered in test. If a dynamic obstacle overlaid the destination just as the robot was 70
PAGE 77
poised to complete the goal, erratic activity on the part of robot was noted. In general. special checking was avoided so as not to dilute the basis of the algorithm . ;, Robot Path Genl"rator Simulation 5 4 3 2 1 1 5 5 s s s 4 4 4 4 5 3 3 3 4 5 2 2 3 4 s 1 2 3 s 7 .. 9 e 7 6 s 4 3 2 1 0 9 8 7 6 s 4 J 2 1 3_3 __ 4_5 7 0 0 1 2 3 4 5 6 7 8 9 1011121314151617181920212223242526272929 0 Obstade 0 Start @ Destination O!G"rllit Robot Definition Speed II] Field VIew EJ Figure 3.44 Test Case 10/Frame 4 Obstacle Overlay the Destination 71
PAGE 78
, Robot Palh Generator Simul111ion 5 4 3 2 1 5 5 5 6 7 #+f, _1_1_2_3 __________________ __. 0 Obstacle 0 Start Destination 181 Path .. .. .. 0 Grid Robot Definition Speed Field VIew Figure 3A5 Test Case 10/Frame 5 Robot Waits for Obstacle to Clear Destination :: .. ; Rnbol Pnth Generntnr Simulation 5 4 3 2 1 2 3 5 3 4 5 .. 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 11 2345 0 o_1_2_J_4_5_e 7 e 9 10111213141516171B192021222J242S26272629 0 Obstacle 0 Start Destination 181 Path 0 !Grid"; .. .. Robot Definition Speed [U FleldVIew Figure 3A6 Test Case 10 As Executed Path 72
PAGE 79
3.4.3.2. Multiple Dynamic Obstacle Scenario In the second of our three scenarios the robot is given a tougher gauntlet to run. Additional and more complex dynamic obstacles are placed in the environment. Table 3.2 presents a defmition of the mobile obstacles that are operating in the scenario. In order to facilitate identification of the mobile obstacle while the test is executing, a letter indicator (A through D) is assigned to each group. The robot is placed at an initial location of (23,4) and given a destination goal of (8,24). The purpose of this test is to see how the robot plans avoidance with multiple mobile obstacle groups in the field of view. Table 3.2 Dynamic Obstacles Defmition for Test Case 11 B (15, 13) ... (16-18) 10 through 23 c (9, 15) ... (12,20) 5 through 14 D (26.24) ... (26,27) 0 through 29 [0,3] 73
PAGE 80
Robot Path Generator Simulation "' I 9 8 7 6 5 4 3 2 1 0 9 e 7 6 5 4 3 2 1 '"' o:-:-1 """'2_,3,.....,..4 """'e-,s"""1-=o"'"'11,...,.1 .,...21-=3..,.,14,...,.15""'1""6 ""11,...,.1 e:-:1""9 :-:20""21:-:22c:-2:l:-:c:-24:-:25-::-2:-:6-:-:27::-::2""e 29:-:1 0 Obstacle 0 Start Destination 0 Grid Robot Definition Speed IIJ Fleldvtew Figure 3.47 Test Case 11/Frame 1 Initial State We pick up the robot situation seven time intervals into the scenario. At this stage (figure 3.48), the robot is moving away from the destination to avoid colliding with obstacle C from table 3.2 moving towards the robot. Obstacle B is also in the field of view moving up on a parallel course with the robot. In the next time interval (figure 3.49), the planning algorithm has encountered a situation where all of the boundary transition locations are either directly blocked or are predicted to be blocked at the point when the robot will reach those locations. In this situation, the planning algorithm processes children nodes of the original transition locations as the most optimal cells in which to move. This is illustrated in 3.49 by a set of trajectories planned only to a distance of 3. 74
PAGE 81
,, 111110 9 10101010 9 9 9 9 e e 8 e 7 7 7 7 7 6 6 7 II 5 7 6 5 4 I 7 6 5 4 3 3 7 6 5 4 4 4 7 6 5 5 5 5 Robot Pi!th Generator Simulation 7 7 3 4 3 2 3 2 3 3 3 4 4 4 5 5 5 5 t .. 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 Obstacle 0 Start Destination l8l Path 0 Grid Robot Definition Speed II] Field VIew Figure 3.48 Test Case 11/Frame 2 Two Dynamic Obstacles in Field of View 75
PAGE 82
;' Robot Path Generator Simulatinn .. I 9 8 7 t 6 s 4 3 2 1 0 9 8 7 6 s 4 3 2 1 0 l-:o:-:-1 -=2:--=-3 -:4,..-:-5 -::s""'7=""""='e-=9,....,""'o,..,.11,....1"'"2"'"'1 3'""1,..,.4 .,...,1 5,...,.1 1=-=1""'1 e='"'1"'"9 ""20'""21,..Z2=n::-:2:-:-4"""2s::-:2"'"s 0 Obstacle 0 Start Desdnallon t8l Path 0 Grid Robot Dellnhlon Speed [] Field VIew [EJ Figure 3.49 Test Case 11/Stage 3 Blocked Boundary Transition Locations In the fmal two frames of this scenario we see the robot apparently on the brink of attaining the assigned goal location (8,24). Obstacle D, however, will overlay the destination of the next time interval. The planning algorithm projects a trajectory around the destination and waits for the obscura to clear the area before moving to the goal. 76
PAGE 83
; /. Robot P11th Generator Simulation I s 5 5 5 5 5 5 4 4 4 4 3 3 3 4 2 2 3 4 2 3 4 2 2 2 3 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 II 7 6 s 4 3 2 1 0 0 Obstade 0 Start Destination O!Gril:ir Robot Definition Speed llJ AeldVIew Figure 3.50 Test Case 11/Stage 4 Unable to Reach Destination Location Robot Path Generator Simulation D!!J 7 6 7 6 7 7 6 4 5 3 5 4 3 5 4 3 s 4 3 5 4 4 5 5 5 5 5 s s 5 5 4 4 4 4 4 5 3 3 3 3 4 5 2 2 2 3 4 5 1 1 2 3 4 5 1 2 3 4 5 2 3 4 5 3 4 5 4 5 s 5 5 0 Obstade 0 Start Destination 0 Grid Definition Speed AeldVIew Figure 3. 51 Test Case 11/Stage 5 Project Trajectory Around Blocked Destination 77
PAGE 84
3.4.3.3. Static and Dynamic Obstacle Scenario In the fmal test scenario the complexity of the environment is again increased. In addition to placing more dynamic obstacles in the area, static obstacles are once again introduced into the domain. Table 3.3 details the movement characteristics of the mobile groups. Table 3.3 Dynamic Obstacles Defmition for Test Cases 12 and 13 A (15, 15) ... (16, 17) 12 through 19 12 through 20 [1,1] B (20,20) 19 through 21 [1,0] c (21,21) 19 through 21 [1,0] D (2,25) ... (5,26) 0 through 29 [0,2] E (2,0) ... (6, 1) 0 through 12 0 through 15 [ 1' 1] F (15,8) ... (17, 13) 5 through 20 5 through 20 [1,1] G (27,0) ... (29,4) 0 through 29 0 through 29 [1.2] H (28,26) ... (29,27) 0 through 29 [3,0] Our first test case in the new environment places the robot inside of a large room at (25, 19). The goal location is placed inside a smaller room at (20,22). The smaller room is blocked by two one-cell dynamic obstacles that traverse the entrance to the room. This test demonstrates the planning algorithms capability to integrate static and mobile obstacle avoidance. Figure 3.53 illustrates the activity that took place in the first time interval. Note the robot expanded the field of view from 5 cells to 8 cells in order to locate an exit to the room. The planning algorithm invoked this option since it could not fmd a location that improved its position relative to the destination. 78
PAGE 85
0 1 .I ] 0 Obstacle 0 Start Destination 0Grtd Definition Speed II] FleldVIew Figure 3.52 Test Case 12/Frame 1 Initial State Robot Path Gcner11tor Simulation -+ 29 28 27 3 2 0 Obstade 0 Start Destination Robot Definition Speed [U Field VIew [U Figure 3.53 Test Case 12/Frame 2 Robot Expands Horizon 79
PAGE 86
Several time intervals later (figure 3.54), the robot is still movmg along the expanded path created in the first time interval. Recall from scenarios presented in previous sections that the execute movement method will not invoke new planning until it has moved to a location that is better than the current location relative to the destination. When this plan was generated, obstacle G was not in the field of view, while in the current time interval the motion of the obstacle has it blocking the path just outside the exit location of the room. Note that the robot could not run at full speed for this time interval: from (25,2) to (26,2). This frame also illustrates for the first time that obstacles overlay each other. Recall from our initial discussion that dynamic and static obstacles can share the same space. ':''; nobol Palh C.cneralor Sirnulalion 0 g 8 1 6 5 4 3 2 1 0 Obatade 0 Start Destination 181 Path 0Grld Definition Speed GJ FieldView Figure 3.54 Test Case 12/Frame 3 Waiting for Obstacle G to Clear Exit Frames 4 and 5 show the robot planning to enter the room containing the goal location. In both frames (figure 3.55, 3.56), the robot is blocked from entry by the two guarding obstacles. In frame 5 however, the planning algorithm should see a path around the obstacles through (19,20) and (19,21). In the fmal frame this path was indeed planned and executed by the robot. 80
PAGE 87
; Robot Path Generiltor Simulation II -+ 5 5 5 5 5 5 4 4 4 4 5 4 J J J 5 4 3 2 2 3 5 4 3 2 1 1 5 4 J 2 1 5 4 3 2 1 1 ] Hi 5 5 5 ..... 0 Obstade 0 Start @ Destination 1:81 Path D Grid Robot Dennltlon Speed [ZJ Field VIew ECJ Figure 3.55 Test Case 12/Frame 4 Blocked From Entry into Room 81
PAGE 88
, Robol P111h Gener111or Simulalion II .... 6 s 5 5 5 4 5 4 5 4 5 4 J 5 4 J 2 s 4 3 s s 4 8 s s 5 9 8 7 6 5 4 J 2 1 0 1 2 3 4 s 6 7 8 9 10 0 Ob&tade 0 Start Deatlnatlon DiGrld! Robot Definition Speed Fleld VIew 5J Figure 3,56 Test Case 12/Frame 5 Set-up Entry into Room Rulool Palh Gener.11nr II .... 0 Obstacle 0 Start Destination 0 Grid Definition Speed Fleld VIew [I] Figure 3.57 Test Case 12/Frame 6 Plot a Trajectory Past the "Sentries" 82
PAGE 89
In a second test case utilizing this obstacle group setup, we place the robot and the goal destination at (25,27) and (0, 12) respectively. At this particular starting point, the robot is in immediate jeopardy from obstacle group H which moves at 3 cells per time interval. To make the initial movement more difficult, a row of obstacles blocking any escape to the south is put in place using the robot simulator static obstacle capability. The purpose of this test is to examine the planning and movement executed by the robot over a long distance in a complex environment. -+ 0 1 .I ] 0 Obetede 0 Start l8l Path 0 Grid -II DellniUon Speed [!] AeldVIew Figure 3.58 Test Case 13/Frame 1 Initial State Frame 2 through 4 (figures 3.59, 3.60, 3.61) are the first 3 time intervals of the test. They demonstrate the robots ability to avoid a faster moving obstacle. In the initial time interval the planning method recognizes the futility of a downward route and plans paths up in the work area, while obstacle H gains a cell on the robot in each time interval. 83
PAGE 90
.I ] 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 J.o,..-1...,2,.....,.3-4_,.5 ""'e,.....,..1 """e-g,.--,1 o,-1-11"""'2-13=-1-4-15_1_6 -17-1-B1_9_20_21_Z2_23_24 __ 25_26 __ 27_2_8......J29 0 Obatade 0 Start @ Destination 181 Path 0 Grid -Jlobot Definition Speed Aeld VIew @] Figure 3.59 Test Case 13/Frame 2 Avoid Faster Element, Time= 1 ] 0 Obstade 0 Start @ Deatlnatlon l8l Path 0 Grid -;:tobot Deftnltlon Speed EJ FleldVIew Figure 3.60 Test Case 13/Frame 3 Avoid Faster Element, Time= 2 84
PAGE 91
Robol P111h Simulalion li] ] 0 Obstacle 0 Start Oeadnatlon 181 Path 0 Grid Definition Speed [] Field VIew EJ Figure 3.61 Test Case 13/Frame 4 Avoid Faster Element, Time= 3 In frame 5 (figure 3.62), we pick up the robot towards the conclusion of the test. The robot plans a path around obstacle E which is overlaying the destination location. Two time intervals later (figure 3.63), the obstacle clears the destination and the robot replans a direct path to the destination. 85
PAGE 92
' Robot Path Generator Simu l ation 0 Obstade 0 Start Destination 0 Grid Definition Speed [] Aeld VIew !TI Figure 3.62 Test Case 13/Frame 5 Blocked Destination : Robot Path c;eneriltor ::;,mulat1on En 5 5 5 5 5 5 5 5 5 4 4 4 4 4 4 4 4 3 3 3 3 3 3 3 5 3 2 2 2 2 2 4 5 3 2 3 4 5 1 2 3 4 5 112345 2 2 2 2 3 4 5 0 Obstade 0 Start Deatlntlon 0 Grtd Definition Speed tJ Field VIew [D Figure 3.63 Test Case 13/Frame 6 Replan After Obstacle Clears Destination 86
PAGE 93
4. SUMMARY AND CONCLUSION This report makes contributions to methods for autonomous mobile robot control. Foremost is the development of geometric reasoning techniques for planning and moving in a complex and dynamic environment. The architecture has demonstrated: Efficient planning and motion for what the domain allows. Responsiveness and adaptability to changes in the environment. Timely completion of all planning activities. Efficiency in the application of resources. Scalability to larger, more complex problem domains. Efficient Planning and Motion Examination of the test cases 1, 2, and 3 easily reveal optimized path planning for the simple environment. With the introduction of static obstacles (test cases 4 through 9) it is somewhat more difficult to demonstrate optimization. Essentially, the planning software optimizes within the field of view. That is, only local obscura can be considered when fmding an optimal path. Global inefficiencies are mitigated by executing the planning algorithm for each motion. This gives the robot the ability to discover global problems more quickly and accommodate them into the plan. Only in test cases 7 and 8 do we see the robot actually backtracking along a path. In both of these cases, the algorithm was seeking a more direct path to the destination outside the field of view, akin to probing ahead for a better route. As soon as it was determined a better path was not available, the algorithm replanned for the available route. Dynamic obstacles add a new criteria to efficient planning: obstacle avoidance. This criteria is of equal value with movement efficiency. Results from test cases 10 through 13 demonstrate obstacle avoidance used in conjunction with movement efficiency. In test case 10, the robot halts movement towards the goal to allow an obstacle to clear the destination location. In that particular situation, movement in any direction would offer less potential. In test case 11 the robot moves away from the destination in frame 3 to avoid an on-coming dynamic obstacle. The movement is minimal and the robot recovers and moves back towards the task goal when the collision threat is clear. In all test cases the robot plans efficiently 87
PAGE 94
for what the environment allows and executes the most effective movement towards the destination. Responsiveness to Change Adaptability to a fluid domain is demonstrated in the response to invisible obstacles and with dynamic obstacle interaction. Invisible obstacles are handled by the software in two ways. First, invoking the planning algorithm with each motion allows the robot to detect previously undetected obscura even within the field view. Second, the motion algorithm always verifies that a previously planned path is still available to it prior to executing motion. If necessary, the motion algorithm can send a "plan" message to invoke the planning algorithm if no paths remain available. Responsiveness to invisible obstacles was successfully demonstrated in test case 8 without loss of efficiency. Dynamic obstacles are more complex. For these situations, the planning software predicts the movement of the obstacles and incorporates the infonnation into the plan. Here again the motion algorithm always verifies path availability prior to engendering movement along the trajectory. This is done in case the situation develops that the obstacle changes direction while a concurrent move occurs. New planning can invoked at this time to consider the new infonnation. Timeliness Completion of Planning Absolute time is, of course, a function of the hardware CPU* compiler efficiency, etc. A more interesting comparison is the relative timeliness of the software in the different environments. Table 4. 1 presents a comparison of the times, in milliseconds, required to execute the planning algorithm in a simple environment, an environment with static obstacles, and an environment with dynamic obstacles. Since the field of view can also affect the results, several variations are provided. The robot speed in all cases was set to two cells per time interval. The tests were conducted on 180486 executing at 33 MHz. The compiler was Borland C++ version 3. 1. 88
PAGE 95
Table 4. 1 Scenario Timing Field of View 3 5 7 Scenario No Obstacles (Test Case 2) 48 51 82 Static Obstacle (Test Case 4) 93 115 109 Dynamic Obstacles (Test Case 11) 95 111 121 Efficient Application of Resources This concept is demonstrated through the judicious use of the "enhanced sensor" capability to expand the robot field of view. As demonstrated in test cases 6 and 8, the robot only invokes the expanded field of view when it is required to obtain an unambiguous path. And, also demonstrated in test cases 6 and 8, once the unambiguous path is obtained, the robot reverts back to the original field of view. In this application the only resource to which the usage concept applied is the field of view. This could easily be expanded within this architecture to incorporate: speed, turning capabilities, etc. Scaleable Architecture A scalar architecture allows for the easy expansion of the software design and implementation into more complex problem domains. In this case, a scalar architecture provided an impetus for the use of object oriented design and programming methodologies. Object oriented programming techniques such as: inheritance, polymorphism and function overloading were used in this design to facilitate reuse and expansion of the design. Design modifications could include: complex robot characteristics (directional field of view, variable speeds), multiple robots, a three dimensional work area, etc. The scalar nature of the architecture was demonstrated by the way in which dynamic obstacles were added to the design. In general, this research shows the applicability of linguistic geometry techniques to understanding the geometric properties and movement in dynamic hierarchical systems 89
PAGE 96
such as mobile robot control. These techniques provide a fonnalized, domain independent approach to such problems. Domain independence offers a rich set of applications in which to apply these techniques. The robot control architecture presented in this report is potentially a model for further applications in scheduling/planning, integrated circuits layout, space vehicle navigation, as well as multiple robot (cooperative and opposing) control scenarios. 90
PAGE 97
APPENDIX A MOBILE ROBOT SIMULATION SOFIWARE The software used to monitor the progress of the robot and control the environment was developed by the author of the thesis in parallel with the development of the application. The simulator is a Microsoft Windows 3.1 based program that graphically depicts the environment and the progress of the robot under test throughout an experiment. The simulator essentially creates a factory-like environment for the robot. Static obstacles may represent equipment and work stations operating in the factory. The static obstacles can also be shaped into walls and rooms simulating a partitioned factory floor with several different work areas to which the robot must navigate. Dynamic obstacles represent mobile elements operating in the factory. They may be other autonomous or remote controlled robots, or some kind of mobile delivery systems (e.g. fork lift, truck, etc.). The robot destination location represents tasking given to the robot. This task may be a job to accomplish, a product to examine, or a part to deliver. The simulator provides three broad categories of scenario control. Environmental control defmes the area in which the robot operates. This includes establishing obstacles, and path display. Robot definition establishes a robot object in the work area and characterizes its capabilities. Robot control directs how the simulator moves the robot will move through the environment. ENviRONMENT CONTROL Environmental control offers options to add obstacles in the work area and to specify display options. 0 Obstacle Obstacles may be placed on the work area in two ways. A data file may be specified on simulator start-up that defines dynamic and static obstacles associated with the scenarios. An example data file is illustrated in figure A-1. Static obstacles may also be placed in the environment by selecting the Obstacle button and then pointing at the 91
PAGE 98
desired location(s) on the work area, and selecting the left mouse button. An obstacle is registered with the Map object and the location is turned black for visual indication. An obstacle can be removed in a similar manner. Obscura can not be placed on top of a current, start, or destination robot location. Static obstacles may be placed in the environment at any stage of an experiment. 4 (15, 15) (16, 15) (16, 16) (16, 17) 1 1 12 19 12 20 Number of dynamic obstacle cells Initial location of dynamic obstacle cells Delta X, Delta Y, Min/Max X, Min/Max Y Figure A-1 Example of a Dynamic Obstacle File Record D Path D Grid The user can control two specific display options through the simulator software. Path toggles the display of the trajectories planned by the robot software. These trajectories are portrayed as numbered locations connected with thin dark lines (see A4 below for an example of the icons described here). The values at the locations represent distances, calculated by the robot software, from the previous robot location. The extent of the numbering illustrates the horizon of the robot in the current time intezval. A thicker green line shows the as-executed robot path. The location containing the green icon specifies the robot location in the current time intezval. The as-executed path and current robot location are always displayed and are not controlled from the simulator software. 92
PAGE 99
RoBar DEFINITION A robot is fundamentally defmed by its speed, horizon, start and destination locations. Robot Definition Speed D FleldVIew D The Speed and Field View parameters characterize the capabilities of the robot in the current experiment. Speed indicates maximum velocity in units of cells per time interval. The robot is allowed total maneuverability without loss of velocity. That is, the robot may turn in any direction or even go backwards without losing any capability to move at full speed. Field View specifies the nominal horizon for the robot. This is represented in units of cells in all directions. The extent of the horizon is unaffected by obstacle interference. It is, however, limited by the edges of the work area, i.e. there is no "wrap around" on the work area. Once the robot has begun an experiment, these parameters can not be modified via the simulation software. The horizon may be temporarily expanded by the robot software under circumstances described in the sections 3. 3 and 3. 4. 0 Start 0 Destination Start and Destination create the respective locations on the work area. Once the button is selected, the user simply points at the desired location in the work area and selects the left mouse button. These locations can be modified in this manner up until experiment execution begins. The destination goal can be modified while the robot is actively pursuing a goal. This simulates the robot receiving higher priority tasking while conducting a mission. The simulation software will not engender movement in the work area unless a start and a destination location are specified on the work area. 93
PAGE 100
RoBar CONTROL The software offers two methods to control the movement of the robot: Execute and Step. An additional function, Reset, terminates the current experiment and allows for defmition of a new scenario. -Execute causes the robot to plan and move to the conclusion of the task. Built into the simulation, is a one second delay between time intervals to allow the user the ability to view the progress of the experiment. Upon selection of this option, the simulator software verifies that a start and task destination are established. Once verified, the one second timer is started. When the timer expires a Move message is sent to the robot. The robot's Move method determines if and when new planning is required. The simulation software queries the robot object for trajectory and path information, as well as, querying the Map object for obstacle movement. While in the execute mode, static obstacles and display features may be modified between time intervals using the environmental controls discussed earlier. Step execute a single time interval in the simulator. At the conclusion of the time interval the simulator stops, waiting for more direction. This feature gives the user the capability of examining the selected path and planned trajectory data before moving on to the next time interval. Similar to Execute mode, robot trajectory, path and obstacle movement data is collected and displayed after the step completes. The user can utilize the environmental controls to display path data, add static obstacles, etc. between steps. The robot task destination can also be changed between stepping actions. Reset causes the current experiment to complete. If this action is taken while the robot is in transit to a task destination, it eliminates current path information and 94
PAGE 101
immediately moves the robot start location to the task destination. If the robot has already reached the task destination it performs a similar function, basically making the current location the new start location. It is important to note that this control is mandatory between experiments. DISPLAY ICONS .I This icon represents a dynamic obstacle group of four cells. These four cells move in a certain direction and at a certain velocity throughout an experiment. -This icon represents a static obstacle occupying three locations. Static obstacles do not move in an experiment This icon represents the robot start location. This appears only at the start of task. This icon represents the robot task destination. This is displayed for the duration of the task. These icons represent the planned trajectories, as-executed robot path and the current location of the robot. 95
PAGE 102
APPENDIX B SOURCE CODE Project.h #ifndef _PROJECTH_ #define _PROJECTH_ {************************************************************************** ** ** project.h ** define structures and macros used by all classes in the model. **************************************************************************! #include
#include
#include
#include
#include "Set.h" #include "List.h" II find the maximum or minimum of two values #define MAX(a,b) ((a) < (b) ? (b) : (a)) #define MIN(a,b) ((a) < (b) ? (a) : (b)) II define a single byte typedef unsigned char Byte_t; II define a 2-D location typedef struct { int x; int y; } Location_t; II define a cell structure in a graph typedef struct { Location_t loc; Byte_t obstacle; Byte_t dist; Byte_t blocked; Byte_t predBlock; Byte_t willBeBlocked; Byte_t pathBlock; Byte_t numChild; Byte_t numParent; void *children; void *parents; void *nxtOnPath; } Graph_t; II flag indicates a static obstacle II flag indicates a dynamic obstacle II flag indicates if robot predicts dynamin obs. II shall be in this location II flag indicates this cell will be blocked by II completion of time increment II flag indicating a this cell was used by an II obstacle to get to a new location II this is cast as graphList in operations II also cast as graphList in operations II signifies next node on chosen robot path 96
PAGE 103
II define a structure for distance display typedef struct { int x; int y; int dist; Dist_t; II define a structure for obstacle information typedef struct { Byte_t id; Byte_t dynamic; int int int Location_t } ObsDef_t; deltaX; deltaY; elemCnt; *loc; const int PATH_CLEAR = 4; const int PATH= 3; const int NEW= 2; const int SET= 1; const int CLEAR = 0; II create templates for Lists and Sets of graph cells typedef Set
graphSet; typedef List
graphList; #endif 97
PAGE 104
robotMap.h #ifndef _ROBOTMAP #define _ROBOTMAP #include "project.h" #include
#include
I*************************************************************************** I class robotMap public: !*constructor-create the work area and assign distances*/ robotMap(int sizeX=lOO, int sizeY=lOO); I* destructor--delete allocated mapping structures*/ -robotMapO; II toggle the state of a location on the graph void obsState(Location_t loc); II explicitly set the state of a location on the graph void obsState(Location_t loc, int state); II check for obstacle in graph int obsCheck(Location_t thisLoc); II clear trajectory information from all cells void clearAbs(void); II clear path information from all cells void ClearPath(void); //measure the theoretical (unimpeded) distance between 2 points int MeasDist (Location_t from, Location_t to); II initialize the distance member of area structure void Distlnit(void); II get all distances Dist_t* GetDist(int *cnt); II generate a list of cells adjacent to input location graphList* GenAdj(Location_t loc, int robSpeed); II convert a location to a cell on the graph Graph_t* compPtr(Location_t loc); 98
PAGE 105
private: }; #endif II add a parent cell to list int AddParent (Graph_t*, Graph_t*); II add a child cell to list int AddChild (Graph_t*, Graph_t*); II get a parent list from a cell graph List* GetParent (Graph_t*); II return the size of the work area void GetWorkAreaSize(int *xSize, int *ySize); II clear the predicted obstacle flag for the range of locations void ClearPredObs(int xMin, int x.Max, int yMin, int yMax); II set the predicted obstacle flag for the given location void SetPredObs(Location_t loc); II make a list of obstacle information available List
* GetObsListO; II set up a list of obstacles int SetObsList(Byte_t dyn,int groupSz, int deltaX, int deltaY,Location_t *deO; II update obstacle location for the specified id void UpdateObsList(Byte_t handle, Location_t *loc, int state, int upDx, int upDy); Graph_t *absArea; List
*obsList; int int int obsCnt; maxmX; maxmY; II work area II list of dynamic obstacles II count of registered dynamic obstacles II maximum allowable size of X dimension II maximum allowable size of Y dimension 99
PAGE 106
robotMap.cpp #include "robotMap.h" #include
#include
#include
II Area map constructor robotMap::robotMap(int xSize, int ySize) { int x,y,minDist, maxDist,llX,llY,urX,urY,xff,i,j; char nxt0bs(80]; Graph_t *absPtr; Byte_t *obsFlag; II create the work area absArea =new Graph_t[xSize*ySize]; II create the dyanmic obstacle list obsList = new List
; obsCnt = 0; II set x.y maximums maxmX = xSize; maxmY = ySize; memset(absArea, 0, xSize*ySize*sizeof(Graph_t)); II initialize the work area absPtr = absArea; for(y=O; y < ySize; y++) for(x=O; x < xSize; x++) { absPtr->loc.x = x; absPtr->loc.y = y; absPtr->dist = 255; absPtr++; II area map destructor robotMap: :-robotMapO { delete absArea; delete obsList; II toggle the state of given location between obstacle/clear void robotMap::obsState(Location_t loc) { Graph_t *obsCell; obsCell = compPtr(loc); if(obsCell->obstacle = 1) 100
PAGE 107
obsCell->obstacle = 0; else obsCell->obstacle = 1; II set the state of a location void robotMap::obsState(Location_t loc, int state) { Graph_t *obsCell; obsCell = compPtr(loc); if(state = NEW && !obsCell->obstacle) { obsCell->willBeBlocked = 1; } else if(obsCell->blocked >= 1 && state = CLEAR) { obsCell->blocked--; } else if(state = SET) { obsCell->willBeBlocked = 0; obsCell->blocked++; } else if(state =PATH) obsCell->pathBlock = 1; else if(state = PATH_CLEAR) obsCell->pathBlock = 0; II convert a locaiton into a pointer to the cell containing that location Graph_t* robotMap::compPtr(Location_t loc) { return absArea + ((loc.y maxmX) + loc.x); II resolve if the location blocked by an obstacle (static/dynamic) int robotMap: :obsCheck(Location_t thisLoc) { Graph_t *thisCell; thisCell = compPtr(thisLoc); if(thisCell->obstacle) return 1; else if (thisCell->blocked) return 2; else return 0; II clear the map of all trajectory information void 101
PAGE 108
robotMap: :clearAbsO { Graph_t *nxtCell; int cnt = maxmX maxmY; while(cnt) { cnt--; nxtCell = absArea + cnt; if(nxtCell->children) delete nxtCell->children; if(nxtCell->parents) delete nxtCell->parents; nxtCell->children = 0; nxtCell->parents = 0; nxtCell->numChild = 0; nxtCell->numParent = 0; II clear the map of all as-executed path information void robotMap:: ClearPathO { Graph_t *nxtCell; int cnt = maxmX maxmY; while(cnt) { cnt--; nxtCell = absArea + cnt; nxtCell->nxtOnPath = NULL; II reset all location distances void robotMap:: Distlnit(void) { int maxm = maxmX maxmY, i; for(i=O; i < maxm; i++) (absArea+i)->dist = 255; II return a list of distances for display Dist_t* robotMap::GetDist(int *cnt) { Dist_t *dists =new Dist_t[900]; inti, x, y; *cnt = 0; for(y=O; y < maxmY; y++) { for(x=O; x < maxmX; x++) { if((absArea+{(y maxmX) + x))->dist < 255) { dists[*cnt].x = x; 102
PAGE 109
} dists[*cnt].y = y; dists[*cnt].dist = (absArea+((y maxrnX) + x))->dist; (*cnt)++; return dists; II measure distances from the current location graphList* robotMap::GenAdj(Location_t cur, int robSpeed) { graphList *adjList =new graphList; Graph_t *newLoc, *curCell; inti, j, curDist; curCell = absArea + ((cur.y maxrnX) + cur.x); curDist = curCell->dist + 1; II do for all adjacent cells for (i=cur.y-1; i <= cur.y + 1; i++) { } II is location on the arena? if(i >= 0 && i < maxrn Y) { forG=cur.x-1; j <= cur.x + 1; j++) { II on the arena & don't reprocess current location again if(G >= 0 && j < maxmX) && G != cur.x I I i 1= cur.y)) { newLoc = absArea + ((i maxrnX) + j); II does location contain an obstacle? if(!newLoc->obstacle && !newLoc->blocked && (curDist > robSpeed II 1newLoc->pathBlock) && (curDist > robSpeed II !newLoc->willBeBlocked) ) if(new Loc->dist = 255) { } adj List-> Addltem (new Loc); AddParent(curCell, newLoc); II add a new parent link II to curCell else if(newLoc->dist = curDist) AddParent(curCell, newLoc); II add a new parent link II to curCell return adjList; 103
PAGE 110
II add a parent to call int robotMap::AddParent (Graph_t *parCell, Graph_t *chldCell) { if(!chldCell->numParent) chldCell->parents = new graphList; if(((graphList *)chldCell->parents)->Addltem(parCell)) { } else chldCell->numParent++; return 1; return 0; II add a child to a parent cell int robotMap::AddChild (Graph_t *parCell, Graph_t *chldCell) { if(!parCe ll->n um Child) parCell->children = new graphList; if(((graphList *)parCell->children)->Addltem(chldCell)) { } else parCell->numChild++; return 1; return 0; II retrieve the parent list from a cell graphList* robotMap::GetParent (Graph_t *cell) { if(cell->numParent) return ((graphList *)cell->parents); else return (graphList *)NULL; II perform a simple column/row distance measurement int robotMap::MeasDist(Location_t from, Location_t to) { int absX, absY, max; II use the max of I xI I y I as distance absX = abs(from.x-to.x); absY = abs(from.y-to.y); max= MAX(absX, absY); return max; 104
PAGE 111
II return the work area size void robotMap::GetWorkAreaSize (int *xSize, int *ySize) { *xSize = maxmX; *ySize = maxm Y; II clear the predicted obstacle flags for a range of locations void robotMap::ClearPredObs (int xMin, int xMax, int yMin, int yMax) { int x,y; Graph_t *cell; Location_t loc; II do for range of x,y locations for(y=O; y < maxmY; y++) { for(x=O; x < maxmX; x++) { II make up a location structure loc.x = x; loc.y = y; II get the cell data associated with this location cell= compPtr(loc); cell->predBlock = 0; II set the predicted obstacle flag for a given location void robotMap: :SetPredObs(Location_t loc) { Graph_t *cell; cell= compPtr(loc); cell->predBlock = 1; II register an obstacle int robotMap::SetObsList(Byte_t dyn, int groupSz, int deltaX, int deltaY, Location_t *deO { ObsDef_t *obsSt; Location_t *cLoc; inti; II extract the pertinent fields obsSt =new ObsDef_t; obsSt->id = ++obsCnt; obsSt->dynamic = dyn; 105
PAGE 112
obsSt->elemCnt = groupSz; obsSt->deltaX = deltaX; obsSt->delta Y = delta Y; obsSt->loc =new Location_t[obsSt->elemCnt]; memcpy(obsSt-> loc, def,obsSt->elem Cnt sizeof(Location_t)); II define the initial obstacle location on the this map cLoc = obsSt->loc; for (i=O; i < groupSz; i++) { obsState(*cLoc, SET); cLoc++; obsList-> Addltem(obsSt); return obsSt->id; II update the parameters for a registered obstacle void robotMap::UpdateObsList(Byte_t handle, Location_t *loc, int state,int upDx, int upDy) { ObsDef_t *obs; inti; Location_t *cLoc; II find the obstacle matching this handle obs = obsList->GetFirstO; while(obs) { if(obs->id =handle) break; else obs = obsList->GetNextO; } if(obs) { II now set the new obstacles and update in the list cLoc = obs->loc; for(i=O; i < obs->elemCnt; i++) { } *cLoc = *(loc+i); obsState(*cLoc, state); cLoc++; obs->deltaX = upDx; obs->delta Y = upDy; II make up a list of obstacle information from registered obstacles List
* robotMap: :GetObsListO { return obsList; 106
PAGE 113
Obstacle.h #ifndef _OBSTACLE_ #define _OBSTACLE_ #include "Project.h" #include "robotMap.h" #include
#include
/*************************************************************************** Define an Obstacle class ***************************************************************************/ class Obstacle public: I* constructor for moving obstacle *I Obstacle (robotMap areaMap, int groupSz, Location_t *groupDef, int deltaX,int deltaY, int xMin, int xMax, int yMin, int yMax); I* destructor*/ -ObstacleO; I* movement method*/ int Move (void); void Reset (void); I* complete the move by removing the obstacle from the locations where it was at the beginning of the move cyle . void CompleteMove(void); private: inline int GetSign(int val) { }; if(val > 0) return 1; else if(val < 0) return -1; else return 0; ObstacleO; II No argument constructor is not legal Byte_t myld; int obGroupSz; robotMap *obAreaMap; Location_t *startDef; Location_t *curGroupDef; II the handle for this obstacle II size of obstacle group //local copy of area map II starting locations for obstacle II current obstacle locations 107
PAGE 114
}; Location_t *shGroupDef; Location_t *intGroupDef; II shadow of obstacle after a move II intermediate locations occupied by II obstacle on way to new location int obDeltaX; II movement in X direction int obDeltaY; II movement in Y direction int startDeltaX; II starting delta X int startDeltaY; II starting delta Y int obxMin, obxMax, obyMin, obyMax; II area of movement int areaX, areaY; //local copy of arena definition int moveSize; II number of intermediate locations in a move int intCnt; II size of intermediate area #endif 108
PAGE 115
Obstacle.cpp /************************************************************ ** Define the obstacle class methods. ***********************************************************/ #include "Obstacle.h" II Dynamic Obstacle Obstacle::Obstacle(robotMap *areaMap,int groupSz, Location_t *groupDef, int deltaX, int deltaY, int xMin, int xMax, int yMin, int yMax) II set up obstacle defintion for this object obAreaMap = areaMap; obGroupSz = groupSz; obDeltaX = startDeltaX = deltaX; obDeltaY = startDeltaY = deltaY; moveSize = MAX(obDeltaX, obDeltaY); obxMin = x.Min; obxMax = xMax; obyMin = yMin; obyMax = yMax; II get and store the work area dimensions obAreaMap->GetWorkAreaSize(&areaX, &area Y); II record obstacle initial location, current, shadow struct for moving startDef =new Location_t[groupSz]; memcpy(startDef, groupDef, groupSz sizeof(Location_t)); curGroupDef =new Location_t[groupSz]; memcpy(curGroupDef, groupDef, groupSz sizeof(Location_t)); shGroupDef =new Location_t[groupSz); memcpy(shGroupDef, groupDef, groupSz sizeof(Location_t)); II create a structure to maintain the intermediate locations through II which an obstacle moves to get to its next location. if(moveSize > 1) { intGroupDef =new Location_t[moveSize groupSz]; II add obstacle to areaMap list my Id = obAreaMap->SetObsList(l ,groupSz,deltaX,delta Y ,curGroupDef); II destructor Obstacle: :-Obstacle 0 { if(curGroupDef) delete curGroupDef; if(startDef) delete startDef; if(shGroupDef) delete shGroupDef; if(moveSize > 1) 109
PAGE 116
delete intGroupDef; void Obstacle:: ResetO { int inti; Location_t *cLoc; for(i=O; i < obGroupSz; i++) { cLoc = (curGroupDef+i); obAreaMap->obsState(*cLoc, CLEAR); memcpy(curGroupDef, startDef, obGroupSz sizeof(Location_t)); II update obstacle location on the area map obAreaMap->UpdateObsList(myld, curGroupDef, SET, startDeltaX, startDeltaY); memcpy(shGroupDef, startDef, obGroupSz sizeof(Location_t)); obDeltaX = startDeltaX; obDeltaY = startDeltaY; 0 bstacle:: Move(void) { int dx, dy, i, xCnt, yCnt, xSign, ySign; Location_t *cLoc, *intLoc; int magDeltX = abs(obDeltaX); int magDeltY = abs(obDeltaY); dx = obDeltaX; dy = obDeltaY; II determine if any part of II obstacle leaves the assigned area of the work area itself II reverse the direction of the obstacle if so for(i=O; i < obGroupSz; i++) { cLoc = (curGroupDef+i); if({(cLoc->x + dx) < obxMin) I I ((cLoc->x + dx) > obxMax) I I ((cLoc->x + dx) < 0) I I ((cLoc->x + dx) > areaX)) obDeltaX = -dx; if(((cLoc->y + dy) < obyMin) I I ((cLoc->y + dy) > obyMax) I I ((cLoc->y + dy) < 0) I I ((cLoc->y + dy) > area Y)) obDelta Y = -dy; II copy current definition of obstacle to shadow locations memcpy(shGroupDef, curGroupDef, obGroupSz sizeof(Location_t)); II if the obstacle speed is greater than 1 in x or y then II must calculate here the path the obtacle will travel to get to 110
PAGE 117
II its new locations. xSign = GetSign(obDeltaX); xCnt = xSign; ySign = GetSign(obDeltaY); yCnt = ySign; intCnt = 0; while((abs(xCnt) < magDeltX) I I (abs(yCnt) < magDeltY)) { II compute intermediate locations and set as blocked for(i=O; i < obGroupSz; i++) { cLoc = (curGroupDef+i); intLoc = (intGroupDef + intCnt); intLoc->x = cLoc->x + xCnt; intLoc->y = cLoc->y + yCnt; intCnt++; obAreaMap->obsState(*intLoc, PATH); II increment to next set of x.y locations xCnt += xSign; yCnt += ySign; II one more time through the loop, this time move the obstacle II in the direction and range set by obDeltaX and obDelta Y for(i=O; i < obGroupSz; i++) { cLoc = (curGroupDef+i); cLoc->x += obDeltaX; cLoc->y += obDelta Y; II update obstacle location on the area map obAreaMap->UpdateObsList(myld, curGroupDef, NEW, obDeltaX, obDeltaY); return 1; II remove where the obstacle was in the current move cycle void Obstacle:: CompleteMove(void) { inti; Location_t *cLoc; for(i=O; i < obGroupSz; i++) { cLoc = (shGroupDef+i); obAreaMap->obsState(*cLoc, CLEAR); for(i=O; i < obGroupSz; i++) { 111
PAGE 118
cLoc = (curGroupDef+i); obAreaMap->obsState(*cLoc, SET); II clear off intermediate locations over which obstacle travelled for(i=O; i < intCnt; i++) { cLoc = (intGroupDef+i); obAreaMap->obsState(*cLoc, PATH_ CLEAR); 112
PAGE 119
Robot.h #ifndef _ROBOT_ #define _ROBOT_ #include "Project.h" #include "robotMap.h" #include
#include
I*************************************************************************** I const int STUCK =-1; const int OK = 0; const int DONE = 1; const int areaSizeX = 30; const int areaSize Y = 30; typedef enum { trans Blocked, trans Back, II blocked from max range of fov transFree, transDest II transition cell is the destination mode_t; class Robot public: I* constructor *I Robot(int robotSpeed, int argMaxExtent, robotMap *argMap); I* destructor *I -Robot(void); I* forecast mobile obstacle movement in FOV *I void PrdctDynObs(int curDist, int fovMinX, int fovMaxX, int fovMinY, int fovMaxY); I* plan the path(s) that are admissible for this situation *I void Plan(Location_t start, Location_t destin); I* generate robot movement along an optimal path *I int II return reached/not reached destination, or stuck Move(Location_t, Location_t); I* return the locations passed thru in the last move *I Location_t* II return number of locations path2Loc(int *); I* return the head of the graph for the robot path *I inline Graph_t* getStartNetO { return graphHead; }; II clear existing path data 113
PAGE 120
inline void clearPaths(void) { my Map->clear AbsO; }; inline void GetPlanExt (int *minX, int *maxX, int *min Y, int *maxY) { } ; private: II return set up from last planning *minX = minExtX; *maxX = maxExtX; *minY = minExtY; *maxY = maxExtY; II determine linear distance between two points using coordiantes inline int calcDist (Location_t from, Location_t to); II make the empty virtual Move call private int Move(void); robotMap *my Map; II Local copy of area map int mySpeed; II Velocity Location_t myDestin; II Current destination Graph_t *graph Head; II Start of path Graph_t *currGrph; II Current cell on path Location_t *lastMove; II List of last location visited int moveCnt; II number of locations visited int maxExtent; II nominal field of view int use Extent; II current field of view int minExtX, maxExtX, minExtY, maxExtY; II mix/max horizon mode_t planMode; II planning mode Queue
curQue, ndLst; II Planning queues }; #endif 114
PAGE 121
Robot.cpp #include "Robot.h" #include
#include
II constructor create the data structures for this robot Robot::Robot(int robotSpeed, int argMaxExtent, robotMap *argMap) { mySpeed = robotSpeed; II number of nodes reachable in one time step myMap = argMap; lastMove =new Location_t[robotSpeed]; moveCnt = 0; planMode = transFree; graphHead = NULL; currGrph = NULL; maxExtent = argMaxExtent; II maximum extent for path planning useExtent = maxExtent; II destructor delete this robot Robot::-RobotO { delete lastMove; II forecast mobile obstacle movement in the current field of view void Robot::PrdctDynObs(int curDist, int fovMinX, int fovMaxX, int fovMinY, int fovMaxY) { Location_t locPred; int i, timeCnt; ObsDef_t *obs; List
*obsList; Location_t *obsLoc; II get a list of all obstacle definitions. The nature of II this function (i.e. what is returned) must change if the robot has II to figure out the obstacle movement pattern. obsList = myMap->GetObsListO; II compute locations at previous time step since obstacle already moved timeCnt = curDist-1; obs = obsList->GetFirstO; II while mobile obstacle not procesed wh.ile(obs) { II if current obstacle is mobile if(obs->dynamic) { II compute location at time step-1 (time step -1 *delta (x andy) if(timeCnt >= 0) { obsLoc = obs->loc; 115
PAGE 122
II for each element of mobile obstacle for(i=O; i < obs->elemCnt; i++) { II if current location is inside field of view then if((obsLoc+i)->x >= fovMinX && (obsLoc+i)->x <= fovMax.X && (obsLoc+i)->y >= fovMin Y && (obsLoc+i)->y <= fovMaxY) locPred.x = (obsLoc+i)->x + (timeCnt obs->deltaX); locPred.y = (obsLoc+i)->y + (timeCnt obs->deltaY); II if location is inside field of view then if(locPred.x >= 0 && locPred.x <= 29 && locPred.y >= 0 && locPred.y <= 29) II set predicted flag for cell at new location my Map->SetPredObs(locPred); II plan robot trajectory paths void Robot::Plan (Location_t start, Location_t destin) { int tDist, cnt, done=O, startDist, mapDist, sumDist, i, chkDone=O; int fovMinX, fovMaxX, fovMinY, fovMaxY; int compDist, maxDist=O, distDest, ddist, minDest=255; int lastDist, travelDist, adjDist = 0; Graph_t *grPtr, *adjPtr, *maxLoc, *transCell, *curCell, *parCell, *anothCell; Graph_t *startCell; graphList *adjList, *mapl..ist, *transl..ist, *parl..ist, *backList, *anothList; Location_t curLoc; II clear any existing path (link) information myMap->clearAbsQ; II initialize distance in work area my Map-> DistlnitO; graphHead = myMap->compPtr(start); II current node is header node of this plan currGrph = graphHead; II compute area boundary for field of view (xmin, xmax, ymin, ymax) curLoc = currGrph->loc; if((fovMinX = curLoc.x-use Extent) < 0) fovMinX = 0; if((fovMaxX = curLoc.x +use Extent)> 29) fovMaxX = 29; if((fovMin Y = curLoc.y-use Extent)< 0) 116
PAGE 123
fovMinY = 0; if((fovMaxY = curLoc.y + use Extent) > 29) fovMaxY = 29; II initialize min/max x,y extents minExtX = 30; maxExtX = 0; minExtY = 30; maxExtY = 0; II calculte theoretical (unimpeded) distance from start to destination tDist = myMap->MeasDist(start, destin); II create a list to contain the boundary locations as transition locs mapList = new graphList; backList = new graphList; grPtr = myMap->compPtr(start); grPtr->dist = 0; II do for each entry in the list while(grPtr) { startDist = grPtr->dist + 1; II get start distance for this set if(grPtr->dist > maxDist) maxDist = grPtr->dist; II generate list cells that are adjacent to this location that are II not obstacles adjList = myMap->GenAdj(grPtr->loc, mySpeed); chkDone = 0; II flag to post a boundary condition only once II for each cell in adjacent list adjPtr = adjList->GetFirstO; while(adjPtr) { II if still in field of view mapDist = myMap->MeasDist(start, adjPtr->loc); if(mapDist <= useExtent) { adjPtr->dist = startDist; II place into proper node list for further expansion ndLst. put(adjPtr); II create an adjacent list until boundary location is found if(startDist > adjDist) { adjDist = startDist; II destroy the old list, create a new, add the item if(backList) delete backList; back.List = new graphList; backList-> Addlte m (adj Ptr); 117
PAGE 124
} else { else if(startDist = adjDist) { backList->Addltem(adjPtr); II check for minimum/maximum x,y condition if(grPtr->loc.x < minExtX) minExtX = grPtr->loc.x; if(grPtr->loc.x > maxExtX) maxExtX = grPtr->loc.x; if(grPtr->loc.y < minExtY) minExtY = grPtr->loc.y; if(grPtr->loc.y > maxExtY) maxExtY = grPtr->loc.y; II put boundary location in transition list if(!chkDone) { chkDone = 1; mapList->Addltem(grPtr); if((distDest = myMap->MeasDist(grPtr->loc, destin)) < minDest) minDest = distDest; II get next cell in adjacent list adjPtr = adjList->GetNextO; delete adjList; grPtr = ndLst.getO; ndLst.clearO; II moving into the path generation phase. First determine the best tran/1 sition points. This is accomplished by finding locations that were II mapped in the above algorithm closest to the final destination. II Paths are generated from start location to these "best" transtion //locations. transCell = myMap->compPtr(destin); planMode = transFree; II if destination is not reachable in the current field of view if(transCell->dist = 255) { II if destination location is being blocked and distance to II destination is within speed of robot and robot will not get clobbered 118
PAGE 125
if((transCell->blocked I I transCell->willBeBlocked I I transCell->pathBlock) && (tDist <= mySpeed) && !currGrph->willBeBlocked) transList = NULL; II is minimum dist to destination >=theoretical distance from start? else if(minDest >= tDist) { if(minDest < 255) { } II this means our best transition locations are all in worse II theoretical position than our start. Generate paths to these II locations anyway, since they are the best we could get. if(backList) delete backList; transList = mapList; planMode = transBlocked; II if no maplist was created then robot was blocked from the II maximum extent of travel. Use the backup list to get as far II as we can. else { planMode = transBack; transList = backList; II else find best locations as transition points else { if(backList) delete backList; distDest = 255; transList = (graphList *)NULL; transList =new graphList; II do until best distance is found maxLoc = mapList->GetFirstO; while(maxLoc) { II compute total distance from current point ddist = myMap->MeasDist(maxLoc->loc, destin); II this check replaces an algorithm that would determine the II true distance of a transition cell to the destination (at II least thru the fov). if(ddist < tDist) { compDist = maxLoc->dist + ddist; if(compDist < distDest) { II destroy the existing "best" list if( trans List) delete transList; 119
PAGE 126
} else { } } transList = new graphList; transList->Addltem(maxLoc); distDest = compDist; else if (compDist = distDest) { II put new location on best list transList->Addltem(maxLoc); II next member maxLoc = mapList->GetNextQ; delete mapList; delete mapList; planMode = transDest; transList = new graphList; transList-> Add! tern (transCell); II for each transition cell, generate the parent-child relationship if(transList) { II clear all previous predicted obstacle flags in the field of view myMap->ClearPredObs(fovMinX, fovMaxX, fovMin Y, fovMaxY); lastDist = 0; startCell = myMap->compPtr(start); transCell = transList->GetFirstQ; w bile (transCell) { curCell = transCell; II do until start location is obtained w hile(curCell) { II compute the affect of dynamic obstacle interaction at travel time II into scenario travelDist = (curCell->dist/mySpeed) + (curCell->dist% mySpeed); if(travelDist != lastDist) { II clear all previous predicted obstacle flags in the field of view myMap->ClearPredObs(fovMinX, fovMaxX, fovMin Y, fovMaxY); if(travelDist > 0) II predict future locations only (already moved) PrdctDynObs(travelDist, fovMinX, fovMaxX, fovMinY, fovMaxY); lastDist = travelDist; 120
PAGE 127
} if(!curCell->predBlock) { } else { II for each parent of current cell, add a child parList = myMap->GetParent(curCell); if(parList) { parCell = parList->GetFirstO; while(parCell) { if(myMap->AddChild(parCell, curCell)) curQue.put(parCell); parCell = parList->GetNextO; II add child cells to the transition list if(transCell->numParent) { anothList = (graphList *)transCell->parents; if(anothList) anothCell = anothList->GetFirstO; while(anothCell) { if(! anoth Cell->willBe Blocked) transList->Addltem(anothCell); anothCell = anothList->GetNextO; curCell = curQue.getO; II get next transition cell transCell = transList->GetNextO; curQue.clearO; II reintiahze the queue delete transList; II make the robot move along a planned trajectory int Robot::Move(Location_t start, Location_t destin) { canst int maxEval = -4096; canst int childFactor = 0; canst int willBeFactor = -100; canst int blockedFactor = -200; canst int onPathFactor = -200; 121
PAGE 128
graphList *currList; Graph_t *currNode, *bestNode, *startCell; int bestEval, linDist,n=O, clrPath=O, curEval, currDist, destDist; int pathDist, testDist; static int totMove = 0, firstTime=O, chkDist; static Graph_t *destNode; moveCnt = 0; II if in transDest mode see if the destination is blocked if(planMode = transDest) { destNode = myMap->compPtr(destin); if(destNode->blocked I I destNode->willBeBlocked) planMode = transFree; II if this is the first move for the robot if((currGrph =NULL) I I (destin.x 1= myDestin.x I I destin.y != myDestin. y)) { myDestin =destin; totMove = 0; destNode = myMap->compPtr(myDestin); myMap->ClearPathO; II plan the initial path to the destination Plan(start, destin); II verify that robot is not already at the destination else if((currGrph->loc.x = myDestin.x) && (currGrph->loc.y = myDestin.y)) { *(lastMove+moveCnt) = currGrph->loc ; moveCnt++; totMove++; return DONE; II do I have a move from the current position or is it time to replan? else if(planMode 1= transDest I I currGrph->numChild = 0) llif(currGrph->numChild = 0) { II add here to replan (Plan) from current location to destination totMove = 0; Plan(currGrph->loc, myDestin); II ii plan is blocked from destination if(planMode = transBlocked) { destDist = myMap->MeasDist(currGrph->loc, myDestin); if(destDist <= mySpeed) { destNode = myMap->compPtr(destin); if(destNode->blocked I I destNode->willBeBlocked) { 122
PAGE 129
planMode = transFree; return OK; while(planMode = transBlocked) { } II increment search extent and replan use Extent++; if(useExtent >= 29) { useExtent = maxExtent; return STUCK; II fail this search Plan(currGrph->loc, my Destin); planMode = transDest; firstTime = 1; useExtent = maxExtent; II reset to normal field of view *(lastMove) = currGrph->loc; currDist = calcDist(currGrph->loc, my Destin); startCell = currGrph; n =0; while(startCell && (n < mySpeed)) { II examine current choices for movement currList = (graphList *)currGrph->children; if(!currList) break; currNode = currList->GetFirstQ; if(!currNode) break; best Node = currGrph; II best is current position bestEval = maxEval; while(currNode) { II eliminate this node from consideration if it contains an II obstacle, if my start node will be blocked and this node II is currently blocked, if this node will be blocked and this II is my final move for this plan. if(currNode->obstacle I I (startCell->willBeBlocked && currNode->blocked) I I (currNode->willBeBlocked && (n+l) = mySpeed)) II check to see if this is the destination if(currNode->loc.x = myDestin.x && currNode->loc.y = myDestin.y) return STUCK; 123
PAGE 130
} II evaluate this node compared to others. Each location starts II with a measurement of how much closer it brings the robot to II the destination than the current location. The cell then gets II points for the number of children it has and loses points for II being warped in a certain way: willBeBlocked, blocked, previous II and previous path. else { } II calculate how much closer this takes robot to destination linDist = calcDist(currNode->loc, my Destin); if(linDist = 0) II currNode is the destination { II found the destination, so pick this one and exit currGrph = currNode; *(lastMove+moveCnt) = currGrph->loc; moveCnt++; totMove++; currGrph = NULL; return DONE; testDist = currDist linDist; II add in the number of children on this node testDist += (currNode->numChild childFactor); II take away for abnormalities if(currNode->willBeBlocked) testDist += willBeFactor; if(currNode->blocked) testDist += blockedFactor; if(currNode->nxtOnPath) testDist += onPathFactor; if(testDist > bestEval) { bestEval = testDist; bestNode = currNode; currNode = currList->GetNextQ; II did we fmd no acceptable nodes'? if(bestEval = maxEval && startCell->willBeBlocked && moveCnt = 0) { II try replanning out of this one if(totMove > 0) { } II clear paths may exist but are not planned, better replan currGrph->blocked = 0; totMove = 0; Plan(currGrph->loc, myDestin); else II I have no paths from the current location { 124
PAGE 131
} moveCnt = 1; break; else if(bestEval = maxEval) II try again next time break; else { II the path to follow is thru currNode currGrph->nxtOnPath = bestNode; if(bestNode->nxtOnPath) bestNode->nxtOnPath = NULL; currGrph = bestNode; *(lastMove+moveCnt) = currGrph->loc; moveCnt++; totMove++; n++; II if we are on a dedicated transition location path if(planMode = transDest) { } if( first Time) { else { firstTime = 0; chkDist = myMap->MeasDist(currGrph->loc, destin); II calculate current distance to destination and compare to last II time through. II Reset flag if distance is now better pathDist = myMap->MeasDist(currGrph->loc, destin); if(pathDist >= chkDist) chkDist = pathDist; else planMode = transFree; return OK; Location_t* Robot: :path2Loc(int *numLocs) { *numLocs = moveCnt; return lastMove; inline int Robot::calcDist(Location_t from, Location_t to) { return (((from.x-to.x) (from.x-to.x)) + ((from.y to.y) (from.y to.y))); 125
PAGE 132
List.h II List.h defines the template for a list class #ifndef _LIST_ #define _LIST_ II A template class for doubly linked lists template
class List { II class Node; public: ListO II Constructor (default) no arguments required : ListHead(O), ListTail(O), Pointer(O) { }; -ListO II Destructor Node *n1, *n2; n 1 = List Head; }; int while (n1 != NULL) { n2 = n1->next; delete n1; n1 = n2; Addltem(const Tc *t) }; II Add an element to the list only if it is II not already present Node *n; n = ListHead; while (n) { if(n->item = t) return 0; II get next n = n->next; n =new Node; n->item = (fc *) t; n->next = 0; n->prev = ListTail; if (ListTail) { } else ListTail->next = n; ListTail = n; ListHead = ListTail = n; return 1; 126
PAGE 133
void Deleteltem(Tc *t) II Delete element from the list { } ; Node *n; int cnt=O; n = ListHead; while (n) { if(n->item = t) { if (n->prev) n->prev->next = n->next; else ListHead = n->next; if (n->next) n->next->prev = n->prev; else ListTail = n->prev; if (n = Pointer) Pointer= n->next; delete n; break; II get next n = n->next; Tc *GetFirstO II Get the first item in the list (reset pointer) }; Pointer = ListHead; if (Pointer) return Pointer->item; else return 0; Tc *GetNextO II Get the next item in the list { if (Pointer) }; Pointer = Pointer->next; else Pointer = ListHead; if (Pointer) return Pointer->item; else return 0; Tc *GetltemO const II Get the current item in the list { if (Pointer) return Pointer->item; else return 0; 127
PAGE 134
private: }; #endif struct Node { }; Tc *item; Node *next; Node *prev; Node *ListHead; Node *ListTail; Node *Pointer; II Nodes of the (doubly linked) list II Pointer to the user's data II Pointer to next item in the list II Pointer to previous item in the list II The list of data elements II Pointer to last element in the list II Current position in the list 128
PAGE 135
Queue.h II Queue.h -defines the template for a Queue class #ifndef _QUEUEH_ #define _QUEUEH_ const int MAX_QUEUE_SIZE = 900; II A template class for queues. Use a simple pointer array as the underlying II structure. template
class Queue { public: QueueO II Constructor (default) -no arguments required : qOut(O}, qlns(O) { }; -QueueQ {}; II Destructor II insert a new element into the queue int put(Tc *item) { }; if(qlns < MAX_QUEUE_SIZE) { } else ptrQueue[qlns] =item; qlns++; return 1; return 0; II the queue is f"illed II extract an element from the queue Tc* get(void) { }; if(qOut = qlns) return NULL; else return ptrQueue[qOut++]; int isEmptyQ { }; if(qOut = qlns) return 1; else return 0; void clearQ { II reset pointers qlns = 0; 129
PAGE 136
qOut = 0; }; private: }; #endif Tc *ptrQueue[MAX_QUEUE_SIZE]; int qlns; int qOut; 130
PAGE 137
BIBLIOGRAPHY 1. Craig, J. J. Introduction to Robotics: Mechanics and Control. 2nd Edition. New York : Addison-Wesley. 1989. 2. Ellis, M. A and Stroustrup, B. The Annotated C++ Reference Manual. New York: Addison-Wesley. 1990. 3. Jones, J. L. and Flynn, A. M. Mobile Robots: Inspiration to Implementation. Wellesley, MA : AK Peters Ltd. 1993. 4. Martin Marietta Astronautics Group (MMAG). Technical Prooosal: Intelligent Mobile Sensor System for Autonomous Monitoring and Inspection. Denver, CO. (1991): 11-1-11-25. 5. Parker, L. E. Heterogeneous Multi-Robot Cooperation. Doctoral Thesis, Massachusetts Institute of Technology. 1994. 6. Petzold, C. Programming Windows 3.1. 3rd Edition. Redmond, W A : Microsoft Press. 1992. 7. Rich, E. and Knight, K. Artificial InteJ.liience. 2nd Edition. New York: McGraw Hill. 1991. 8. Stilrnan, B. "From Serial to Concurrent Motions in Multiagent Systems: A Linguistic Geometry Approach." Journal of Systems Engineering (To Appear 1996): 1-33. 9. Stilrnan, B. "Translations of Network Languages." An International Journal: Computers and Mathematics with Applications. Vol. 27, No. 2 (1994): 65-98. 10. Stilrnan, B. "A Syntactic Hierarchy for Robotic Systems." Integrated Computer Aided Engineering Vol. No. 1 (1993): 57-82. 11. Stilrnan, B. "A Linguistic Approach to Geometric Reasoning." An International Journal: Computers and Mathematics with Applications. Vol. 26, No. 8 (1992): 29-58. 131
©Auraria Library
SobekCM
Library Site Index
|
Library FAQs
|
Ask Us
|
Send a Comment | http://digital.auraria.edu/AA00001879/00001 | CC-MAIN-2017-39 | en | refinedweb |
Devoxx, and all similar conferences, is a place where you make new discoveries, continually. One of these, in my case, at last week's Devoxx, started from a discussion with Jaroslav Bachorik from the VisualVM team. He had presented VisualVM's extensibility in a session at Devoxx. I had heard that, when creating extensions for VisualVM, one can also create new charts using VisualVM's own charting API. Jaroslav confirmed this and we created a small demo together to prove it, i.e., there's a charting API in VisualVM. Since VisualVM is based on the NetBeans Platform, I went further and included the VisualVM charts in a generic NetBeans Platform application.
Then I wondered what the differences are between JFreeChart and VisualVM charts, so asked the VisualVM chart architect, Jiri Sedlacek. He sent me a very interesting answer:
JFreeCharts are great for creating any kind of static graphs (typically for reports). They provide support for all types of existing chart types. The benefit of using JFreeChart is fully customizable appearance and export to various formats. The only problem of this library is that it's not primarily designed for displaying live data. You can hack it to display data in real time, but the performance is poor.
That's why I've created the VisualVM charts. The primary (and so far only) goal is to provide charts optimized for displaying live data with minimal performance and memory overhead. You can easily display a fullscreen graph and it will still scroll smoothly while running and adding new values (when running on physical hardware, virtualized environment may give slightly worse results). There's a real rendering engine behind the charts which ensures that only the changed areas of the chart are repainted (no full-repaints because of a 1px change). Scrolling the chart means moving the already rendered image and only painting the newly displayed area. Last but not least, the charts are optimized for displaying over a remote X session - rendering is automatically switched to low-quality ensuring good response times and interactivity.
The Tracer engine introduced in VisualVM 1.3 further improves performance of the charts. I've intensively profiled and optimized the charts to minimize the cpu cycles/memory allocations for each repaint. As of now, I believe that the VisualVM charts are the fastest real time Java charts with the lowest cpu/memory footprint.
Best of all is that everything described above is in the JDK. That's because VisualVM is in the JDK. Here's a small NetBeans Platform application (though you could also use the VisualVM chart API without using the NetBeans Platform, just include these JARs on your classpath: org-netbeans-lib-profiler-charts.jar, com-sun-tools-visualvm-charts.jar, com-sun-tools-visualvm-uisupport.jar and org-netbeans-lib-profiler-ui.jar) that makes use of the VisualVM chart API outlined above:
The chart that you see above is updated in real time and you can change to full screen and you can scroll through it and, at the same time, there is no lag and it is very performant. Below is all the code (from the unit test package in the VisualVM sources) that you see in the JPanel above:
public class Demo extends JPanel { private static final long SLEEP_TIME = 500; private static final int VALUES_LIMIT = 150; private static final int ITEMS_COUNT = 8; private SimpleXYChartSupport support; public Demo() {; public void run() { while (true) {); } catch (Exception e) { e.printStackTrace(System.err); } } } private Generator(SimpleXYChartSupport support) { this.support = support; } } }
Here is the related Javadoc. To get started using the VisualVM charts in your own application, read this blog, and then look in the "lib" folder of the JDK to find the JARs you will need.
And then have fun with real-time data in your Java desktop applications.
{{ parent.title || parent.header.title}}
{{ parent.tldr }}
{{ parent.linkDescription }}{{ parent.urlSource.name }} | https://dzone.com/articles/real-time-charts-java-desktop | CC-MAIN-2017-39 | en | refinedweb |
CodePlexProject Hosting for Open Source Software
I am considering which CMS to use for my eCommerce platform, to do this I am playing with orchard to see if I could make it fit....
I am following the tutorials to create a ContentPartRecord called Product which has SKU, Price etc. However I also want it to have a reference to a 'unit of measure' which is in a seperate accounting system.
Am I able to write my own implementation of the IRepository to allow me to load this via EntityFramework? How would this work during editing?
Would I be able to do something like:
builder.RegisterGeneric(typeof(ExternalRepository<UnitOfMeasure>)).As(typeof(IRepository<UnitOfMeasure>)).InstancePerDependency();
But where would I put this in my Module? Could I share this between multiple modules that share this dependancy?
Orchard looks great, but a bit of help would be nice to get me up and running quickly.
Many Thanks.
Edit: I copied DataModule from Orchard.Framework.Data and did this:
builder.RegisterType<ExternalRepository<Foo>>().As<IRepository<Foo>>().InstancePerDependency();
This seems to send an ExternalRepository<Foo> into my FooHandler when I request an IRepository<Foo>.
I am going to see if I can get Orchard to read/write content parts through this interface.
Concerning your question about dependencies and sharing them across modules, I think you found the solution: Define an "autofac module" (autofac module != orchard module) registration class and inject your dependency. As for sharing between
modules, you probably want to make sure specify dependencies in your "Module.txt" file as this would ensure your module doing the registration is enabled and active when you enable other modules depending on it.
Concerning customizing IRepository, this is an interesting approach to the problem. I'd be curious to see if you can get it to work this way, it would be awesome. That said, if i understand properly your scenario, you don't really need to have a specific
repository implementation. You could just have a content handler that instantiates a "LazyField" in your part, and that "LazyField" would handle retrieving the data from an external source (and you could use EF directly there I suppose).
The other issue to figure out is transactions of course.
Note that this would only work if Orchard does have the list of content items in its own database (e.g. i'm assuming you followed the tutorial and that your "Products" are content items). If you need to have everything in a separate back-end, it
gets more tricky (because Orchard currently really needs content item IDs from its own ContentItem record table). In that case, what we have seen (for the Orchard Gallery for example) is people creating an Orchard background tasks that can read from a "log"
table/service provided by the back end, and ensure content items (Ids) are in sync with the back-end.
HTH,
Renaud
Hi Renaud,
Thanks very much for your response, I am doing this the way you have suggested, but I have come up against a problem. Here is the class I am using to test with:
public class AddressPartRecord : ContentPartRecord
{
public virtual string Address { get; set; }
public virtual StateRecord StateRecord { get; set; }
public Uom Uom { get; set; }
}
(I am using the 1-n tutorial). The StateRecord stuff all works fine, so I assumed I would be able to simply present an IRepository<Uom> and it would all be happy, however I get the following error from NHibernate:
"An association from the table default_Maps_AddressPartRecord refers to an unmapped class: MyNamespace.Entities.Uom"
This is why i removed the 'virtual' keyword from the definition - to no avail.
Is there anyway of getting round this problem? I have no experience with NHibernate, and I originally assumed it would use the generic IRepository<Uom> to deal with this data, but now I see that is an Orchard class, and so there must be
a deeper connection here. Is there an attribute or something I can use to correct this? I have added Uom_Id in the database in the same manor as StateRecord_Id, if I were to use a different convention on this name would NHibernate ignore this relationship?
Ah I see...
Hmm, i don't think this approach is going to work: NHibernate needs to understand all the types you are using (including Uom in this case), and they need to be mapped to a table AFAIK. IRepository<T> is an Orchard concept built on top of
NHibernate, so NHib won't know that Uom persistance is handled by IRepository<T>.
I think i'd try something like this instead:
public class AddressPartRecord : ContentPartRecord
{
public virtual string Address { get; set; }
public virtual StateRecord StateRecord { get; set; }
public virtual int UomId { get; set; }
}
public class AddressPart : ContentPart<AddressPartRecord>
{
public string Address { get { return Record.Address;} }
public StateRecord StateRecord { get { return Record.StateRecord;} }
public LazyField<Uom> UomField { get; set; }
public Uom Uom { get { return UomField.Value; } set { UomField.Value = value;} }
}
then write a AddressPartHandler handler that hooks up UomField UomId of the AddressPartRecord table (using EF I suppose). There are examples of using LazyField in a few Orchard modules, I believe..
The thing that is still not clear to me is transaction management. I don't know how i would go about coordinating the changes to "Uom" and "AddressPartRecord". Is "Uom" writable, or is it just a "read-only" reference
table?
Yes I think your right. I will have to abandon that. But referencing it in the ContentPart is fine. I have not seen your LazyField stuff - I will have to take a look.
There will be no changes to Uom via referencing entities. So there is not really a great need to have it Object referenced, ID is fine. The only thing it will be used for is Display, apart from in the external system where it is used properly.
Of course it wont be on an Address, but a Product!
I want to be able to update Uom and other entities inside Orchard, but weather I do this via IRepository or some other mechanism I have yet to see... I've only downloaded Orchard today.
Thank you very much for your help - I'll let you know how I get on.
Regards,
James
Hi, i have basicly the same question:
I have an external dataservice dll and want to load data from that dll within a module service. Is this possible or do i really have to do this in an parthandler?
Thanks!
You can access it from anywhere you like. You'd do it from a part handler or driver if that data needed displaying as part of a content item or widget.
Are you sure you want to delete this post? You will not be able to recover it later.
Are you sure you want to delete this thread? You will not be able to recover it later. | https://orchard.codeplex.com/discussions/244157 | CC-MAIN-2017-39 | en | refinedweb |
I am a python coder but recently started a forey into Java. I am trying to understand a specific piece of code but am running into difficulties which I believe are associated with not knowing Java too well, yet.
Something that stood out to me is that sometimes inside class definitions methods are called twice. I am wondering why that is? For example:
The following code is taken from a file called ApplicationCreator.java. I noticed that the public class ApplicationCreator essentially instantiates itself twice, or am I missing something here?
public class ApplicationCreator<MR> implements
IResourceObjectCreator<BinaryRuleSet<MR>> {
private String type;
public ApplicationCreator() {
this("rule.application");
}
public ApplicationCreator(String type) {
this.type = type;
}
1) Why would the class instantiate itself inside the class?
The class is not calling itself, it is proving a way for others to instantiate its object. Read about constructor.
2) Why would it do so twice? Or is this a way to set certain parameters of the ApplicationCreator class to new values?
As I said, it is a way to create object. 1st one will assign default value to type. And 2nd will give others an option to assign a value. Read about constructor overloading.
this in the constructor will call another constructor of the same class depending upon argument type passed to this. | https://codedump.io/share/zTQBzKqtLmHf/1/why-specify-a-method-twice---java | CC-MAIN-2017-39 | en | refinedweb |
Collections and Data Structures
Closely related data can be handled more efficiently when grouped together into a collection. Instead of writing separate code to handle each individual object, you can use the same code to process all the elements of a.
Generic collection classes make it easy to create strongly typed collections. See the System.Collections.Generic and System.Collections.ObjectModel namespaces.
The LINQ to Objects feature allows you. LINQ queries can also improve performance. For more information, see LINQ to Objects. | https://msdn.microsoft.com/en-us/library/7y3x785f(v=vs.95).aspx | CC-MAIN-2017-39 | en | refinedweb |
Hi folks.
I've been playing about with the GUI part of the game I'm working on. I have a Box class which basically draws a rectangle but has a load of properties to display information in the space, one of which is text.
If I use the MeasureString function on text displayed 1:1 it's fine, however if I display text at .5 size and multiply the MeasureString by the same variable the text moves right and down,
Has anyone else found this?
I can't see how my calculations can be wrong, all I'm doing is multiplying the measure result by the ratio then divide it by 2 to find the centre point. For testing I'm using a very standard Tahoma that's been 'spritefonted'.
I could spriteify loads of different sizes of font, but that seems wasteful.
Any ideas?Thanks.
@MuntyScruntFundle maybe (not tested)you can just do: MeasureString(YOURTEXTHERE) * SIZEOFYOURFONTi dont know, it woud be the first thing i thought of here...
MeasureString returns the width and height of text at its 1/1 point size.MeasureString returns the width and height of multiple lines of text as well as the total.
for example if each of the below letters were 10x10 pixels and you sent the following lines to MeasureString.
ABBBBBCC
MeasureString would return a size of 50,30
This is not useful for positioning of a rectangles x,y position elements directly.
It's not all that great of a function nor is it efficient. I did some experiments that allowed a great deal of, 'on the fly' manipulation to text however unfortunately i couldn't get the same speed.
I could use / post those classes and share them if spritebatch had a full overload that allowed one to pass vertice positions LT RT RB LB of a quad to spritebatch it really should i don't know why we don't have a direct overload that allows you to pass directly the vertice positions. All that is just extra overhead anyways that is done by spritebatch.DrawRectangle.
It's just that no one implemented it yet. This came up on GitHub in a discussion before. I'm sure a good PR that implements this behavior would be accepted
Have you tried not doing that? I thing the origin is in relation to the 1/1 text size.
Which part exactly is the bottleneck? How would you take advance of a SpriteBatch that lets you batch primitives to draw text faster?
SpriteBatch is specialized at drawing rectangles/quads. The only reason I see in passing vertices is for arbitrary shapes/polygons, but then it will have to accept any polygon size, at entire different request IMO.
Sorry for the late reply i didn't see this.
How would you take advance of a SpriteBatch that lets you batch primitives to draw text faster?
I have quite a few methods for cutting text and manipulating text on the fly. Including a couple extra classes that do a little more advanced manipulation on words or paragraphs and colors.
Most of these rely on being able to directly define vertice edges of the quads the colors of the quads, command text within the strings passed themselves avoiding MeasureString in the drawString command precomputing rotations on the fly ect.
For example in one method i call this in my own drawstring.
spriteBatch.Draw(tsf.Texture, dest, currentGlyph.BoundsInTexture, color, rotation, Vector2.Zero, SpriteEffects.None, depth);
If i am need of a overload that allows me to set the vertices directly.Then i already know what the 2d representation of the quad is on screen 3 dimensionally.
All of the below bolded feilds are then redundant in the draw method but will be recomputed anyways.
Further the dest and bounds will be recalculated to floats in that draw but i have just calculated the integers from floats to pass to that method. I also know the color per glyph, i may even know the color per vertice i want for the text to give off a cool cheap effect or highlight some words. I may want to simulate italicized text by drawing a quadrilateral quad instead of a directly square one ect.
Spritebatcher is very efficient at this point and its limited to squares that are all of the same color.However this limitation is in fact completely redundant and not really neccessary, from its wrapper class Spritebatch's and its Draw overloads this can actually be inefficient in some cases. It also is pointless reduced functionality there is no reason Draw should only take squares it is certainly not for performance.
I don't have a way to efficiently bypass the extra junk in draw to basically give a quad to spriteBatcher which would be nice.
Anyways...
To keep on topic of the post i made this little class for cutting strings today.I figured id post it to share or for posterity.
This just cuts down and returns a string or gives the index for a string for were it is to get cut off by a bounding rectangles width. This should work with scaling as well, its very simple it uses the same algorithm that DrawString itself uses though this might be a bit simplified.
I didn't include cutting it off for the bounds height though its easy to add it yourself if you want.
using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
namespace Microsoft.Xna.Framework
{
public static class TextMeasure
{
private static SpriteFont tsf;
private static Dictionary<char, SpriteFont.Glyph> _glyphs;
private static SpriteFont.Glyph defaultGlyph;
private static char defaultfontchar = ' ';
public static void SetSpriteFont(SpriteFont s)
{
tsf = s;
_glyphs = tsf.GetGlyphs();
defaultGlyph = new SpriteFont.Glyph();
if (tsf.DefaultCharacter.HasValue)
{
defaultfontchar = (char)(tsf.DefaultCharacter.Value);
defaultGlyph = _glyphs[defaultfontchar];
}
}
public static string CutStringByBounds(string text, Rectangle boundRect)
{
var i = CutStringsEndingCharIndex(text, Vector2.One, boundRect);
return text.Substring(0, i);
}
public static string CutStringByBounds(SpriteFont sf, string text, Rectangle boundRect)
{
SetSpriteFont(sf);
var i = CutStringsEndingCharIndex(text, Vector2.One, boundRect);
return text.Substring(0, i);
}
public static string CutStringByBounds(SpriteFont sf, string text, Vector2 scale, Rectangle boundRect)
{
SetSpriteFont(sf);
var i = CutStringsEndingCharIndex(text, scale, boundRect);
return text.Substring(0, i);
}
public static string CutStringByBounds(string text, Vector2 scale, Rectangle boundRect)
{
var i = CutStringsEndingCharIndex(text, scale, boundRect);
return text.Substring(0, i);
}
public static int CutStringsEndingCharIndex(string text, Rectangle boundRect)
{
return CutStringsEndingCharIndex(text, Vector2.One, boundRect);
}
public static int CutStringsEndingCharIndex(SpriteFont sf, string text, Rectangle boundRect)
{
SetSpriteFont(sf);
return CutStringsEndingCharIndex(text, Vector2.One, boundRect);
}
public static int CutStringsEndingCharIndex(SpriteFont sf, string text, Vector2 scale, Rectangle boundRect)
{
SetSpriteFont(sf);
return CutStringsEndingCharIndex(text, scale, boundRect);
}
public static int CutStringsEndingCharIndex(string text, Vector2 scale, Rectangle boundRect)
{
var lineHeight = (float)tsf.LineSpacing;
var Spacing = tsf.Spacing;
Vector2 offset = Vector2.Zero;
Rectangle dest = new Rectangle();
var currentGlyph = SpriteFont.Glyph.Empty;
var firstGlyphOfLine = true;
int result = 0;
for (var i = 0; i < text.Length; i++)
{
var c = text[i];
if (c == '\r')
continue;
if (c == '\n')
{
offset.X = 0;
offset.Y += lineHeight;
firstGlyphOfLine = true;
continue;
}
if (_glyphs.ContainsKey(c))
currentGlyph = _glyphs[c];
else
if (!tsf.DefaultCharacter.HasValue)
throw new ArgumentException("Text Contains a Unresolvable Character");
else
currentGlyph = defaultGlyph;
// Solves the problem- the first character on a line with a negative left side bearing.
if (firstGlyphOfLine)
{
offset.X = Math.Max(currentGlyph.LeftSideBearing, 0);
firstGlyphOfLine = false;
}
else
offset.X += Spacing + currentGlyph.LeftSideBearing;
// matrix calculations unrolled removed un-needed here
var m = offset;
m.X += currentGlyph.Cropping.X;
m.Y += currentGlyph.Cropping.Y;
dest = new Rectangle(
(int)(m.X * scale.X),
(int)(m.Y * scale.Y),
(int)(currentGlyph.BoundsInTexture.Width * scale.X),
(int)(currentGlyph.BoundsInTexture.Height * scale.Y)
);
if (dest.Right < boundRect.Width)
{
result = i + 1;
}
else
{
return result;
}
offset.X += currentGlyph.Width + currentGlyph.RightSideBearing;
}
return result;
}
}
}
Its used like so...
text = TextMeasure.CutStringByBounds(font, text, textBoundingRectangle); | http://community.monogame.net/t/measurestring-and-font-scaling/9366/7 | CC-MAIN-2017-39 | en | refinedweb |
first 2.0.1
Return the first true value of an iterable.
first: The function you always missed in Python
first is an MIT licensed Python package with a simple function that returns the first true value from an iterable, or None if there is none. If you need more power, you can also supply a key function that is used to judge the truth value of the element or a default value if None doesn’t fit your use case.
I’m using the term “true” consistently with Python docs for any() and all() — it means that the value evaluates to true like: True, 1, "foo" or [None]. But not: None, False or 0. In JavaScript, they call this “truthy”.
Examples
A simple example to get started:
>>> from first import first >>> first([0, None, False, [], (), 42]) 42
However, it’s especially useful for dealing with regular expressions in if/elif/else branches:
import re from first import first re1 = re.compile('b(.*)') re2 = re.compile('a(.*)') m = first(regexp.match('abc') for regexp in [re1, re2]) if not m: print('no match!') elif m.re is re1: print('re1', m.group(1)) elif m.re is re2: print('re2', m.group(1))
The optional key function gives you even more selection power. If you want to return the first even number from a list, just do the following:
>>> from first import first >>> first([1, 1, 3, 4, 5], key=lambda x: x % 2 == 0) 4
default on the other hand allows you to specify a value that is returned if none of the elements is true:
>>> from first import first >>> first([0, None, False, [], ()], default=42) 42
Usage
The package consists of one module consisting of one function:
from first import first first(iterable, default=None, key=None)
This function returns the first element of iterable that is true if key is None. If there is no true element, the value of default is returned, which is None by default.
If a callable is supplied in key, the result of key(element) is used to judge the truth value of the element, but the element itself is returned.
first has no dependencies and should work with any Python available. Of course, it works with the awesome Python 3 everybody should be using.
Alternatives
first brings nothing to the table that wasn’t possible before. However the existing solutions aren’t very idiomatic for such a common and simple problem.
The following constructs are equivalent to first(seq) and work since Python 2.6:
next(itertools.ifilter(None, seq), None) next(itertools.ifilter(bool, seq), None) next((x for x in seq if x), None)
None of them is as pretty as I’d like them to be. The re example from above would look like the following:
next(itertools.ifilter(None, (regexp.match('abc') for regexp in [re1, re2])), None) next((regexp.match('abc') for regexp in [re1, re2] if regexp.match('abc')), None)
Note that in the second case you have to call regexp.match() twice. For comparison, one more time the first-version:
first(regexp.match('abc') for regexp in [re1, re2])
Idiomatic, clear and readable. Pythonic. :)
Background
The idea for first goes back to a discussion I had with Łukasz Langa about how the re example above is painful in Python. We figured such a function is missing Python, however it’s rather unlikely we’d get it in and even if, it wouldn’t get in before 3.4 anyway, which is years away as of yours truly is writing this.
So I decided to release it as a package for now. If it proves popular enough, it may even make it into Python’s stdlib in the end.
History
2.0.1 (2013-08-04)
- Make installable on systems that don’t support UTF-8 by default.
- Backward incompatible: Drop support for Python older than 2.6, the previous fix gets too convoluted otherwise. Please don’t use Python < 2.6 anyway. I beg you. N.B. that this is a pure packaging/QA matter: the module still works perfectly with ancient Python versions.
2.0.0 (2012-10-13)
- pred proved to be rather useless. Changed to key which is just a selector. This is a backward incompatible change and the reason for going 2.0.
- Add default argument which is returned instead of None if no true element is found.
1.0.2 (2012-10-09)
- Fix packaging. I get this never right the first time. :-/
1.0.1 (2012-10-09)
- Documentation fixes only.
1.0.0 (2012-10-09)
- Initial release.
Credits
“first” is written and maintained by Hynek Schlawack and various contributors:
- Łukasz Langa
- Nick Coghlan
- Vincent Driessen
-.0
- Programming Language :: Python :: 3.1
- Programming Language :: Python :: 3.2
- Programming Language :: Python :: 3.3
- Topic :: Software Development :: Libraries :: Python Modules
- Package Index Owner: hynek
- DOAP record: first-2.0.1.xml | https://pypi.python.org/pypi/first | CC-MAIN-2017-39 | en | refinedweb |
Now that your sound files are ready, let’s see how we can use them. All sound-related classes belong to the flash.media package and will be introduced throughout this chapter.
The Sound class gets access to the audio information to load the sound file. It is a subclass of the EventDispatcher class.
As discussed before, your sound can be embedded, it can be loaded as an external file from your application assets directory, or it can be downloaded from a remote server. For the latter, advise your audience to use WiFi over 3G for a better experience.
If you try to play a sound that is not loaded, you will get a runtime error. Create a listener to be notified when the loading is complete, and then play your file:
import flash.media.Sound;
import flash.net.URLRequest;
import flash.events.Event;
var sound:Sound = new Sound();
sound.addEventListener(Event.COMPLETE, onLoaded);
var request:URLRequest = new URLRequest(“mySound.mp3”);
sound.load(request);
// sound fully loaded
function onLoaded(event:Event):void {
sound.removeEventListener(Event.COMPLETE, onLoaded);
sound.play();
}
You can inform the user that the file has started to load:
sound.addEventListener(Event.OPEN, onOpen);
function onOpen(event:Event):void {
trace(“sound loading”);
}
If it is a large file, create a listener to display the progress:
import flash.events.ProgressEvent;
sound.addEventListener(ProgressEvent.PROGRESS, onLoading);
function onLoading(event:ProgressEvent):void {
// display the percentage loaded
trace(event.bytesLoaded/event.bytesTotal)*100);
}
On Android devices, it is important to check for errors, particularly if the file is served from a remote server. Inform your user if there is a network issue:
import flash.events.IOErrorEvent;
sound.addEventListener(IOErrorEvent.IO_ERROR, onError);
function onError(event:IOErrorEvent):void {
trace(“sound cannot be loaded”, event.text);
}
Streaming
Streaming is the process of playing part of a sound file while other parts are loading in the background. The advantage is that you don’t need to wait for the whole file to download before playing. In addition, you can play very long tracks without memory constraints.
The audio files must be located on a streaming server. The quality of the server is an important factor to a good experience: 128 kbps is sufficient for audio, but a musician can detect artifacts in high frequency for MP3 encoding. Encoding your audio at 192 kbps is a good compromise.
Requesting the file is the same process as before.
You can start playing the audio as soon as there is enough data in the buffer. Buffering is the process of receiving and storing audio data before it is played. The default buffer time is 1,000 milliseconds. You can overwrite the default using the SoundLoaderCon text class.
In this example, the buffer time is changed to five seconds:
import flash.media.SoundLoaderContext;
var sound:Sound = new Sound();
var request:URLRequest = new URLRequest(“myStreamingSound.mp3”);
var context:SoundLoaderContext = new SoundLoaderContext(5000, true);
sound.load(request, context);
sound.play();
The SoundLoaderContext class is also used for security checks when loading sounds, but it may not be required in AIR.
Streaming MP3 files is buggy when it comes to midstream bit rate changes, a method often used by streaming services such as Internet radios. The audio sounds like it speeds up or is broken in chunks because it uses the bit rate declared at the start of the stream, even after a change. | https://www.blograby.com/developer/working-with-sounds-loading-sounds.html | CC-MAIN-2017-39 | en | refinedweb |
", Protocol: "REST" Track this Search Promoted API Name Description Category Updated iSIGHT Partners Threatscape iSIGHT Partners Threatscape API is a fee based API that allows integration of iSIGHT Partners cyber security products and third party technology to produce content rich intelligence data. iSIGHT... Security 01.28.2015 TomTom Map Input Tracker The Map Input Tracker API by TomTom allows businesses to crowdsource the detection of real world changes as well as general map feedback. By crowdsourcing map feedback, TomTom helps map providers... Mapping Appbase Appbase is a realtime graph data store for rapid app development. The Appbase API uses REST principles. Using HTTP calls, developers can list and create vertices and edges, filter vertices by... Database-as-a-Service 01.21 Google Cloud Monitoring Google Cloud Monitoring provides access to metrics and data from the Google Cloud Platform. Developers can access and integrate the functionality of Google Cloud Monitoring with other applications.... Cloud 01.20.2015 Flashphoner Flashphoner is a web call server that allows users to access VoIP, web calling, messaging, streaming, and other WebRTC communication functions. The Flashphoner API allows developers to access and... VoIP 01.20.2015 Stepic Stepic is an online educational website providing lessons in a variety of subjects. Use the Stepic REST API to access information from the Stepic site like announcements, assignments, courses, and... Education 01.19.2015 Idyl Cloud Idyl Cloud by Mountain Fog is a webservice that provides entity extraction from tweets and natural language text and language detection. The Idyl Cloud lets users integrate entity extraction into... Natural Language Processing 01 Kassabok Kassabok is an online website that provides users with a way to keep track of their expenses and income. The Kassabok API lets developers integrate its services with their applications, enabling... Budget 01.11.2015 Teleport Teleport is a Canada based company that provides customers ability to record, view, and edit time-lapse videos, and share them as Teleport feeds. The Teleport API lets developers integrate its... Cameras 01.11.2015 Eet.nu Eet.nu is a web based company that provides users with information about restaurants in and around Belgium, Serbia, and The Netherlands areas. The Eet.nu lets developers integrate its database with... Restaurants 01.11.2015 TryMyUI TryMyUI is a site that can be used to acquire feedback on web software usability from users. Try My UI will find targeted demographics from a customizable testing pool size to rate a user interface.... Ratings 01.11.2015 Brightcove Dynamic Ingest Brightcove Dynamic Ingest API can be used to retrieve video assets and create new renditions. For the Brightcove video publishing platform, the Ingest API syncs with files that are downloaded form... Video 01.11.2015 GeoBulk Reverse Geocoding GeoBulk offers a simple reverse geocoding API. The API accepts longitude and latitude coordinates over HTTP GET requests, and returns a specific address as a JSON serialized object. The API offers... Geography 01.11 Postmates Delivery Postmates is a courier service accessible via Android and iOS apps, allowing offices or individual users to request deliveries form any restaurant or store. Using the Postmates Delivery API,... Transportation 01.09.2015 Platfora REST Platfora is a big data analytics company that provide businesses a way to analyze their data. The Platfora REST API lets developers integrate the Platfora's services with their applications,... Big Data 01.08.2015 Mojio Push The Mojio Push API is a RESTful interface that lets developers to get real-time notifications whenever conditions are met for events that happen to an entity e.g. a vehicle, connected car. With this... Notifications 01.08.2015 Buttercoin Buttercoin is a bitcoin and cryptocurrency buying, selling, and trading platform. The Buttercoin API allows developers to connect their applications to the Buttercoin Marketplace to deposit and... Bitcoin 01.08.2015 AT&T Verify Connect AT&T Verify Connect is a service that assists with identifying customers who access mobile and web-based services by assigning each customer with a unique digital ID. With the API, developers... Verification 01.08.2015 AT&T Address Book The AT&T Address Book API is a cloud-based service that lets developers to integrate its service with their applications, enabling their customers to manage their wireless contacts . The Address... Addresses 01.08.2015 AT&T Enhanced WebRTC The AT&T Enhanced WebRTC (Web Real Time Communication) API lets developers build real time Web browser-based communication applications by discovering other parties in communication. The API... Real Time 01.08.2015 TimezDB TimezDB is a time zone database for many locations/cities around the globe. The TimezDB API allows developers to access and integrate the functionality of TimezDB with other applications. Some... Time 01 GitHub Search GitHub's Search API allows you to search GitHub for any specific item you're looking for (users, files, unresolved issues). Each search will return up to 1,000 results and the default sort... Tools 01 Dooing Dooing is a mobile management platform that allows users to manage people and projects across locations. The Dooing API allows developers to access and integrate the functionality of Dooing with... Project Management 01.07.2015 Insteon Insteon is a home-automation system. Insteon allows users to automate various functions at home, such as lighting, power outlets, and wall switches. The Insteon API allows developers to access and... Home Automation 01.06 Sony Lifelog Sony Lifelog is an application for wearables that tracks and records various data from the user, such as health information, fitness information, and goal tracking. The Sony Lifelog API allows... Wearable 01.06.2015 Rapt Rapt Media is a platform that allows users to create and build interactive video features for any device, platform, or application. The Rapt Media API allows developers to access and integrate the... Video 01.06.2015 TargetingMantra TargetingMantra is an online personalization platform. TargetingMantra provides personalized and customized online platforms that cater to the user's specific needs. The TargetingMantra API... Marketing 01.06.2015 Misfit Misfit has a variety of wearable technology products that track a user's activity, health data, sleep, and more. The Misfit API allows developers to access and integrate Misfit’s functionality... Wearable 01.06.2015 GameSparks GameSparks is a cloud-based platform that provides developers with the tools they need to build the server-side components of their games and then manage them as a service post launch. The GameSparks... Games 01.06.2015 AllRecharge AllRecharge API is a service for B2B that aggregates online payment and mobile recharge services into a single API package. Using the RESTful AllRecharge API, developers can implement requests using... API 01.06.2015 iCity iCity Project is a project that was developed with the intention to build up a Linked Open Apps Ecosystem based upon the vision of Linked Open Data. The iCity API offers ways to obtain information... Cities 01.05.2015 Words WordsAPI is a RESTful API that allows a user to query a database of definitions for over 150,000 words in the English language. The API can also respond with specific details for a word, including... Dictionary 01.05.2015 EBANX EBANX is an eCommerce payment solution for international merchants that are selling their products to Brazil-based individuals. Using the EBANX API, developers can integrate the EBANX payment... eCommerce 01.05 Ideonet Ideonet is a Polish service offering tools for group coordination and project collaboration. Tasks can be divided and group communication can be integrated using Ideonet's services. The platform... Organization 01.05.2015 CodePen Codepen is a browser-based HTML, CSS, and JavaScript code editor that supplies an instant preview of what is being programmed. Codepen is also described as a playground for front end developers, a... HTML5 01.05.2015 Under Armour Under Armour, the sports and fitness clothing company, offers a fitness platform that fuels applications such as Under Armour Women, MapMyFitness, MapMyRun, MapMyRide, MapMyWalk, and MapMyHike to... Wearable 01.05.2015 Connect Media Bulk SMS Connect Media offers an API for bulk SMS distribution,. The platform includes a Gateway and IT support systems to enable direct SMS sent from websites. The RESTful API works in XML format, and... Messaging 01.03.2015 FIFO URL FIFO URL is a URL shortening service. The FIFO API communicates in JSON format and requires an API key for use. Developers are allowed access to the service in order to programmatically shorten URLs... URL Shortener 01.02.2015 GardenKit GreenIQ's GardenKit API provides access to their product, Smart Garden Hub. Smart Garden Hub is an application that aims to cut down water consumption in gardens and landscapes. The GardenKit... Internet of Things 01.01.2015 Wrapulous Wrapulous is a simple link shortening and click tracking API. The API requires an API key and uses HTTP basic authentication for use. Using the Wrapulous API, developers can make GET and POST HTTP... URL Shortener 01.01 BitPay Bitpay is an online payment service that uses bitcoins, it provides people a platform to make payments online. The BitPay API is REST based, which enables developers to integrate its services into... Bitcoin 12.30 Ammando Ammando is a global crowdsourcing platform where visitors can donate to support millions of fundraisers and non profits worldwide. The platform supports 75+ different currency types. Using the... Crowdsourcing 12.29.2014 Alina Currently in a private beta, Alina is an API that leverages machine learning, coining itself as an intelligence-as-a-service provider. The API also provides cloud-based natural language processing. A... Machine Learning 12.29.2014 Coupon The Coupon API supported by Stage of Life provides access to a large number of discounts on U.S. based brands by partnering with hundreds of national companies. These coupons range anywhere from 5%... Coupons 12.27 DeviceHive DeviceHive is a framework for machine-to-machine communication that can be used to bring connected devices into the Internet of Things. DeviceHive provides control software, and platform specific... Machine-to-Machine 12.26.2014 Button Loyalty Button's DeepLink commerce gives developers the ability to link complimentary apps together in order to extend app functionalities across apps and drive adoption by increasing downloads. For... Linked Data 12.26.2014 AT&T Advertising The AT&T Advertising API gives web and mobile applications the ability to programmatically retrieve and insert advertisements, and to collect a revenue share based off of user engagement.... Advertising 12.26.2014 Direct Mail Direct Mail is an app for Mac OSX that allows users to design email newsletters and create and send bulk email campaigns, with campaign performance monitoring as well as subscriber list management... Email 12.26.2014 Espago Espago is a Polish payment gateway for eCommerce that processes online card payment methods. Espago hosts an API sandbox to allow developers to test the API. Espago can be used to process bank... Payments Pixuate Pixuate offers a suite of image processing services that includes facial recognition, object recognition, scanning and textual character matching, and more. The Pixuate Web APIs can be implemented... Images 12.26.2014 Bitcoin.co.id Bitcoin.co.id is a platform where users can check current BitCoin prices, and purchase and sell Bitcoin using Rupiah, the Indonesian currency. The Public Bitcoin.co.id API allows anyone to make HTTP... Bitcoin 12.26.2014 Debrid Link Debrid Link is a downloader and seedbox host for downloading files stored on filehosters, and for exchanging information using the BitTorrent protocol across remote servers. This torrent application... Torrents 12.26 Grimoire Grimoire provides access to a datastore to help elucidate the Conjure programming language. The datastore contains information regarding symbols, namespaces, and packages within the Closure ecosystem... Application Development 12.26.2014 1 2 3 … 80 next › | http://www.programmableweb.com/category/all/apis?data_format=21173%2C21190&order=created&sort=desc | CC-MAIN-2015-06 | en | refinedweb |
TemplatesEdit
We already mentioned templates briefly in our section on tagging. Now we're going to get into some of the more advanced features of them. Templates, their features, and their uses is a huge topic of discussion and is far too big for the scope of this book alone. The book Editing Wikitext will include more information about Templates than this book does, but even that isn't comprehensive resource. The best way to learn is to see other templates in action, or to ask some of our active users for help and see what solutions they come up with.
Templates have several benefits. First is that templates help to hide large, complex features from the page. That means that when new users contribute to a page, they don't need to dig through large quantities of formatting first. Second, templates can be used to apply very similar markups to multiple pages (or to multiple points in a single page) without having to copy and paste large amounts of code. Finally, through the use of parameters, templates can help to automate many tasks that otherwise would need to be performed by hand.
Templates are a special case of including pages. To include, or transclude, a page in the current one, the syntax is {{namespace:page name}}. For the main namespace, you leave the namespace part blank and just use {{:page name}}. The default namespace is Template:, so just putting in {{page name}} will try to include Template:page name, which is good if you are using templates.
Try including a page in the sandbox, E.g. include the main page using
This is how print versions of books are created. Each page is included in order on the print version page. Anything that shouldn't show up on the print version is put between <noinclude> </noinclude> in the code of the pages being included, which stops it being included when the page is included in another one. This is used to hide the navigation links and other stuff that only people looking at the book online would be interested in. Conversely if you want something to only appear for people viewing your print version, you use <includeonly> </includeonly>.
Templates use the same idea, only for different purposes and with some added features. An example of a simple template, which is used with just {{page name}}, could be
{{incomplete}}
which makes
This is an example of a standard template just to save time. Tags like this can also be used to generate lists of books which are incomplete. If you go to Template:incomplete and click on the "What links here" link in the toolbox, the pages which have "(inclusion)" listed after them are pages which have included the template. For the {{incomplete}} template, an editor could use this to get a list of pages which are incomplete.
When you type {{incomplete}}, you are actually including the code from Template:incomplete, which looks like:
'''The text in its current form is incomplete.'''
That's pretty boring. You can use <includeonly> ... </includeonly> to mark sections of a template that should appear when transcluded, but should not appear on the template page itself. You can use <noinclude> ... </noinclude> to mark sections that should not be included. You can use this, for instance, to include the template in one category, but include pages that template is transcluded onto in another category. You can also display documentation on the template page about proper use of the template, without that documentation appearing everywhere you use the template. So if you wanted someone who went to look at the template page for {{incomplete}} to see what its purpose was after "The text in its current form is incomplete." you could replace the code with
'''The text in its current form is incomplete.''' <noinclude> '''Purpose:''' :This template is used to designate a page as incomplete </noinclude>
which would show people
The text in its current form is incomplete.
Purpose:
- This template is used to designate a page as incomplete
When they looked at the template page but only The text in its current form is incomplete. when they included it.
You can also be tricky with your categories:
<includeonly> '''The text in its current form is incomplete.''' [[Category:Pages that are incomplete]] </includeonly> <noinclude> '''Purpose:''' :This template is used to designate a page as incomplete [[Category:Templates that do tricky things]] </noinclude>
Template ParametersEdit
The {{Message Box}} template is a little more complex because it uses parameters. Parameters are values which a template will use when making its code for a page including it. When you include Template:Message_box, You need to pass it parameters. If you just do
{{Message box}}
you get
Huh? This template actually has 2 parameters which we need to pass arguments to. If we include the template like
{{Message box|heading = hello|message = goodbye}}
you get
When including Templates you don't need to worry about spaces or capitalizing the first letter, but the page names are still case sensitive for all the other letters, so if you type
{{Message Box|heading = hello|message = goodbye}}
you get
Because of the "Box" instead of "box".
Back to the example... heading and message are the names of the parameters of Template:Message_box. The actual code for the template looks like
<center class="metadata"> <table style="width: 60%; background: {{{backgroundcolor|transparent}}}; border: 1px solid #aaa; padding: 0.5em;"><tr> <td style="width: 70px;">[[Image:{{{image|Wikibooks-logo.svg}}}|60px|{{{alt|logo}}}]]</td> <td>'''{{{heading}}}'''<br /><small>{{{message}}}</small></td> </tr></table> </center>
Wow, now that is complicated. Everything with three pairs of braces around it is a parameter. So there are 5 parameters, which are backgroundcolor, image, alt, heading, and message. The first 3 parameters have pipe characters in them. These create default values for the parameters, so that even if we only pass values for heading and message, the background is still transparent, the image shown is still the Wikibooks logo and the alternate text of that image is still "logo". If a parameter doesn't have a default value and you don't pass a value to it, it just shows the parameters name in 3 pairs of braces, which is why it made {{{heading}}} and {{{message}}} the first time.
But that doesn't mean we can't change these values. Say we want to get a green background, with a smiley image, and the alternate text "smile", with the same heading and message we used last time. To get this you would type
{{Message box|backgroundcolor = green|image = Face-smile.svg|alt = smile|heading = hello|message = goodbye}}
and get
It doesn't matter what order you pass arguments to the parameters in, as long as they are named. It does matter if the parameters use numbered parameters like {{{1}}}. If the parameter is numbered then you need to put it in the right place, so if it is {{{1}}} it would be the first value you pass.
The only thing limiting what you can achieve with templates is your imagination and you knowledge of HTML and CSS (used to make things look pretty), as well as a knowledge of variables and parser functions. That and the template limits of the mediawiki software to avoid large workloads on the server, but this only really matters if you are transcluding a page which transcludes a page which transcludes a page, and will probably only bug you if you are a book writer trying to sort all your pages into chapter pages, and then trying to include those chapter pages in a print version, or something like that. When you try to include a page which includes other pages and it goes over the include limit a link will just be placed onto the page pointing to the page you wanted to transclude, and I think there is some kind of error message generated in the HTML code as a comment.
Advanced EditingEdit
There are a number of advanced tools that an editor can use to create better pages and templates. Many of these features are extensions to the MediaWiki software. New extensions can be added to Wikibooks, on occasion. If you can think of a feature that we don't have here, you can check out the list of available extensions on Mediawiki.org. Before anything gets installed, however, you need to get community approval on the Technical Reading Room.
Extensions that We Can't GetEdit
There are a number of extensions that Wikibookians have asked for in the past, but that we cannot have installed. Frequently, this is because of performance issues: Some extensions take up too many server resources. Sometimes, it's because of security: some extensions just haven't been rigourously tested enough to go live on a big site like Wikibooks. Here is a list of extensions and functionality that we have asked for and have not been able to get:
- DPL
- We do have an old version of DPL installed, but the new version has many more options and much more power. Unfortunately, all that power comes at the price of increased server load. Until the efficiency of this extension goes up, we are unlikely to see an upgraded version here on Wikibooks.
- GNU LilyPond
- Lilypond is an extension for allowing all sorts of LaTeX-based markups, including graphics, music, etc. Unfortunately, this extension has multiple components, many of which have not been rigourously security-tested.
- StringFunctions
- Like the parser functions, these are parser hooks that can be used to manipulate string data. This includes tokenizing, manipulating, etc. This extension also requires too much server power, and so it can't be installed here on Wikibooks.
HTML and CSSEdit
Wikitext is converted to HTML by the MediaWiki software. We use wikitext because it is easier to read and edit then plain HTML. However, there are plenty of occasions where we need to use HTML and CSS to perform a variety of tasks.
CSS ClassesEdit
Here are some common CSS classes that are used around wikibooks. Making use of these classes in your own work will help to keep everything standardized, and can save a lot of effort if you are trying to duplicate complicated styles.
- PrettyTextBox
- PrettyTextBox is a CSS class that produces a box with a grey background and a grey border. Examples of this textbox are {{SideBox}} and {{TextBox}}. A common implemention of this is
<div class="PrettyTextBox">...</div>.
- wikitable and wikitable
- These classes are used for tables that are similar to the PrettyTextBox color theme, above. The regular table cells are grey, header cells are darker grey, and all the cells have a grey border around them. This format is commonly used in many places, such as The Reading Room.
- metadata, noprint
- These classes cause items on your page not to appear when you print a book. This is useful for certain message or note templates that are intended more for writers than for readers.
- printonly
- Like those above, but opposite. Objects with class printonly will only appear when you print a page, but will not appear when you view the page online.
- plainlinks
- When you create an external link, the software automatically includes a little icon next to the link to indicate what type of resource that link points to. Using the plainlinks class will hide these little icons.
Parser FunctionsEdit
Parser functions are powerful but complicated. They are best served in the template namespace, where their complexity can be hidden from people who edit books and pages. Using parser functions in a book page will make the code more difficult to read and understand. Therefore, the page will be more difficult for regular contributors to edit. The version of the parser functions that we have is not the complete, nor the most recent version. Documentation for our version is located here:
We do not have the "Extended" version of the parser functions, nor the "StringFunctions" extension, nor any of the other related extensions.
Math TagsEdit
Visit the sciences, math, or engineering subject pages, and you are likely to see mathematical formulae. These are rendered using a LaTeX variant specifically designed for mathematics. You can see the complete markup help sheet at meta:Help:Displaying a formula. A more comprehensive version of this page can be found on meta and Wikipedia.
Dynamic Page ListsEdit
Dynamic page lists (DPL) is an extension that automatically generates a list of pages based on the category and namespaces of those pages. Complete documentation for our version of DPL (which is not the most recent version, see the note above) is located at:
This feature is used mostly in organizational pages, such as the Subject Namespace, and other places. It is not commonly found in books, but that doesnt mean it can't be.
Flattening DPL ListsEdit
DPL Lists, by default, appear in a vertical bulleted list. However, using the CSS class
DPLFlat we can force the list to be horizontal instead. For example:
<div class="DPLFlat"><dynamicpagelist>...</dynamicpagelist></div>
This use is demonstrated on {{New}}. | http://en.m.wikibooks.org/wiki/Using_Wikibooks/Advanced_Techniques | CC-MAIN-2015-06 | en | refinedweb |
#include <proton/import_export.h>
#include <proton/message.h>
Go to the source code of this file.
The messenger API provides a high level interface for sending and receiving AMQP messages.
Messenger
Subscription
Construct a new Messenger with the given name. The name is global. If a NULL name is supplied, a UUID based name will be chosen.
Frees a Messenger.
Gets the certificate file for a Messenger.
Gets the incoming window for a Messenger.
Gets the outgoing window for a Messenger.
Gets the private key file password for a Messenger.
Gets the private key file for a Messenger.
Retrieves the timeout for a Messenger.
Gets the trusted certificates database for a Messenger.
Returns the number of messages in the incoming message queue of a messenger.
Gets the tracker for the message most recently fetched by pn_messenger_get.
Interrupts a messenger that is blocking. This method may be safely called from a different thread than the one that is blocking.
Retrieves the name of a Messenger.
Returns the number of messages in the outgoing message queue of a messenger.
Gets the tracker for the message most recently provided to pn_messenger_put.
Returns the number of messages currently being received by a messenger.
Instructs the messenger to receives up to limit messages into the incoming message queue of a messenger. If limit is -1, Messenger will receive as many messages as it can buffer internally. If the messenger is in blocking mode, this call will block until at least one message is available in the incoming queue.
Each call to pn_messenger_recv replaces the previos receive operation, so pn_messenger_recv(messenger, 0) will cancel any outstanding receive.
Adds a routing rule to a Messenger's internal routing table.
The route procedure may be used to influence how a messenger will internally treat a given address or class of addresses. Every call to the route procedure will result in messenger appending a routing rule to its internal routing table.
Whenever a message is presented to a messenger for delivery, it will match the address of this message against the set of routing rules in order. The first rule to match will be triggered, and instead of routing based on the address presented in the message, the messenger will route based on the address supplied in the rule.
The pattern matching syntax supports two types of matches, a '%' will match any character except a '/', and a '*' will match any character including a '/'.
A routing address is specified as a normal AMQP address, however it may additionally use substitution variables from the pattern match that triggered the rule.
Any message sent to "foo" will be routed to "amqp://foo.com":
pn_messenger_route("foo", "amqp://foo.com");
Any message sent to "foobar" will be routed to "amqp://foo.com/bar":
pn_messenger_route("foobar", "amqp://foo.com/bar");
Any message sent to bar/<path> will be routed to the corresponding path within the amqp://bar.com domain:
pn_messenger_route("bar/*", "amqp://bar.com/$1");
Route all messages over TLS:
pn_messenger_route("amqp:*", "amqps:$1")
Supply credentials for foo.com:
pn_messenger_route("amqp://foo.com/*", "amqp://user:[email protected]/$1");
Supply credentials for all domains:
pn_messenger_route("amqp://*", "amqp://user:password@$1");
Route all addresses through a single proxy while preserving the original destination:
pn_messenger_route("amqp://%/*", "amqp://user:password@proxy/$1/$2");
Route any address through a single broker:
pn_messenger_route("*", "amqp://user:password@broker/$1");
Sends messages in the outgoing message queue for a messenger. This call will block until the indicated number of messages have been sent. If n is -1 this call will block until all outgoing messages have been sent. If n is 0 then this call won't block.
Provides a certificate that will be used to identify the local Messenger to the peer.
Sets the incoming window for a Messenger. If the incoming window is set to a positive value, then after each call to pn_messenger_accept or pn_messenger_reject, the Messenger will track the status of that many deliveries.
Sets the outgoing window for a Messenger. If the outgoing window is set to a positive value, then after each call to pn_messenger_send, the Messenger will track the status of that many deliveries.
Sets the private key password for a Messenger.
Provides the private key that was used to sign the certificate. See pn_messenger_set_certificate
Sets the timeout for a Messenger. A negative timeout means infinite.
Sets the trusted certificates database for a Messenger. Messenger will use this database to validate the certificate provided by the peer.
Gets the last known remote state of the delivery associated with the given tracker.
Subscribes a messenger to messages from the specified source.
Sends or receives any outstanding messages queued for a messenger. This will block for the indicated timeout. | http://qpid.apache.org/releases/qpid-proton-0.5/protocol-engine/c/api/messenger_8h.html | CC-MAIN-2015-06 | en | refinedweb |
You can subscribe to this list here.
Showing
2
results of 2
>>>>> "Andrew" == Andrew Straw <astraw@...> writes:
Andrew> Hi All, OK, I've got tick/grid positioning and labeling
Andrew> working now, too.
Thanks! I have incorporated your changes into CVS, and added some new
functions to matlab.py (semilogx, semilogy, loglog). I have done some
additional work to make the tick labels and automatic view lim behave
properly (eg, labeling only the decades, which becomes important for
data with a wide range of decades, and doing a better job of
autosetting the view lim for log scaling). There is still some work
to be done, for example to properly handle the case where the axis lim
are set by the user, and where the scale is changed interactively, but
I thought the existing code was useful enough to do a new release of
the sourceforge site, 0.29.2.
One the remaining issues are cleared up, I want to do a release to the
wider python community, so please report any bugs.
Thanks again, Andrew. Keep them coming.
JDH
Some example code :
from matplotlib.matlab import *
dt = 0.01
t = arange(dt, 20.0, dt)
subplot(311)
semilogy(t, exp(-t/5.0))
subplot(312)
semilogx(t, sin(2*pi*t))
subplot(313)
loglog(t, exp(-t/10.0))
show() | http://sourceforge.net/p/matplotlib/mailman/matplotlib-users/?viewmonth=200310&viewday=21 | CC-MAIN-2015-06 | en | refinedweb |
Support meetings/20080210
From OLPC
Sunday, Feb 10 2008, 4-6PM EST
Attendees
Community Support Volunteers confirmed: (please add your name if we missed you!)
- John Webster (Arizona)
- Alan Claver (Pennsylvania)
- Seth Woodworth (New York / Oregon)
- Aaron Konstam (Texas)
- Kate Davis (Middletown, CT)
- Mel Chua (New Jersey, NYC) (only on irc)
- ixo (Bellingham, WA)
- Ian Daniher (Ohio)
- Sebastian Silva (Lima, Peru)
- FFM (Virginia)
- Sandy Culver (Massachusetts)
- Greg Babbing (New Hampshire)
- Sebastian (Peru)
- Others ?
1CC
- Adam Holt (1CC, Support Gangster in Chief)
- Henry Hardy (1CC)
- Kim Quirk (1CC)
- SJ Klein (1CC)
- Greg Babbin (1CC)
- Arjun Sarwal (1CC)
- Andriani Ferti (1CC)
Not confirmed:
- Katherine Elliott (Massachusetts)
TOPIC: Guest Speaker Henry Hardy, new employee from Ohio/Michigan
- "The History of the Net", his 1993 Masters thesis:
(which is mentioned in !)
- What he (OLPC's new SysAdmin) intends to bring to OLPC
- Why OLPC genuinely need a Historian. How _you_ might help.
- Aaron Konstam mentions SAGE.
TOPIC: Billing/Shipping True Love.
- Kim and Adam summarized where we're at, and how we're approaching the March finishing line.
TOPIC: Paper Letters.
- Why our team need only answer those paper letters that include email addresses.
TOPIC: OLPC Re-org
- Reorg into 4 working groups - 1 leader for each group, still in flux, leaders being sought.
- (rest of notes lost)
TOPIC: pushing out update.1 (build 656)....
- Urgent need, fix for battery issues...
- likely resolve alot of reported battery issues out there.
- Best before 30 day warranty expires.
- Warning: will uninstall non-Sugar Activity, addins, etc..... "
- What's the best method for letting users know ?
- ffm/Phil have an install flash script which may help.
- Kate mentions, a new release of olpc-update, may resolve 'non-standard' addons, and search path.
- [Action item] ffm will update wiki flash page, to install flash 'best method'.
- Kim confirmed, auto updates , will create alt image.... for revert.... Boot-O image available
- If you want to participate, with auto-update,
- update streams info...
TOPIC: Peru implementation
- Sebastian talking about Peru, Walter Bender will be down there next week...
- support-gang is a good resource for issue triage / supplementary support...
- Kim suggestion: gather together grassroots people from surrounding area,
- During the visit, and bring people together... to help create local support structure.
- OLPC can't provide resources for coordinating Peru grassroots or people.
- Encourage people in the area to come together and create something.
- Possible forum could be setup by volunteers in US, for Peru...
- Idea: setup a separate email address alongside of 'help@' (ayuda@laptop ?), for keeping Spanish / South American FAQ/RFTM straight and not-confusing.
- Thoughts about wiki and language integration
- Is separate Wiki needed for Peru (or language?) -- most people agree - NO. (only if demand requires it)
- Continue with current translation efforts.
- Suggestion: Sebastian (Peru) and Xavi (Argentina) coordinate together some espanol resources for both countries.
- wiki/language discussion taken off line for later discussion between ffm, Kim, etc..
TOPIC: RT Feeping Creaturism
- Need review of automated reply template that SJ edited and Adam reverted
- Suggestions:
- Adding more info on first page, like tracking #, etc . . .
- Try avoiding promising too much to customers, already promised too much
- More than one category on ticket.."
- Work on quality, avoid speeding through as many as you can...
- Keep an eye on RMA tickets, make sure less than 30 days.
TOPIC: Speak Their Minds - What was YOUR toughest challenge this week?
- Mchua: Speaking my mind: Toughest challenge == lack of transcript in this call, hard for me to get information otherwise ;)
- Holt: Last week's 1-time experiment with live transcript failed dramatically. Despite extensive precautions on my part and others'.
- SJ: toughest challenge: finding out what /everyone else/ was up to
- SJ: suggestion.. encourage others to do Week in Review..... nice record... of what's happening in small bits..
- looks great and self acknowledgement of what you've been working on.
- Still clarifing exact format or location, but under your own User namespace page is good start.
- Encourage others for clear communication on what's going on and where.
- ixo: would be nice to see some stats/numbers on volunteers active, and how many hours donated to OLPC
- Idea: Each volunteer login centrally, track hours in week/month donated, descriptions generic, details optional
- Good method to also be able to ack volunteer work and stats.
TOPIC: Donor receipts for Laptops.
- Can call Donor services for official receipt.
TOPIC: Weekly Zine launch:
- ixo: Current update, is that first issue is almost ready to go. Last articles, put in today.
- 'public soft release' monday morning in english, with translations soon behind it within 24/36 hours.
- Seth / isforinsects, and others have pulled together a great collection of items, and fleshing out quite nicely.
- ffm: olpczine.org is not quite ready to go, still waiting on a few configuration settings.
- MChua: Some futher ideas on structure for future issues.
TOPIC: Documentation update
- mchua: Template:Grassroots group and Template:Project have been made, pls use
- Chris Carrick from Olin has a team that's looking at OLPC wiki usability for their class...
- ..crazy-chris and I and possibly others are doing a hackathon session on organizing pilots-related wiki stuff this thursday,
- ..possibly trying to start a "how to run a pilot" handbook and finding existing pilots to help fill it in
TOPIC: Funds Development.
- Stay posted. Thanks for all your great ideas this week!
TOPIC: Vesna/Holt/SJ on "Social Cartography" (skimmed quickly over)
- how 60+ of us here can each get to know each other Much Better?
- How can we improve ?
- Has everyone created a teamwiki account? Start here if not:
Minutes THANKS to
- ixo (last minute secretary, typing one handed while holding the phone w/oher)
- ffm (briefly filled in, while ixo took a break)
Briefly edited for clearity by Holt. | http://wiki.laptop.org/go/Support_meetings/20080210 | CC-MAIN-2015-06 | en | refinedweb |
Python “decorator” is a language construct that lets you define a wrapper function g to another function f, such that, when f is called, your wrapper g is called instead. (it can also be applied to methods, and class.)
The syntax for “decorator” is
@name1 immediately before the line of
def name2.
Here's a decorator:
@g def f(): print("xyz")
is equivalent to
def f(): print("xyz") f = g(f)
That is ALL there is of Python decorators.
Note that:
fis called, the wrapper
gwill be called instead.
greceives
fas its argument.
gmust return a function. Because, remember, the value of
fis now
g(f), and
fis a function. So, when
fis called such as
f(3), Python evaluates
g(f)(3), so
g(f)must be a function too. (technically, it just need to be anything callable.)
Here's a example of decorator:
# -*- coding: utf-8 -*- # python # example of a decorator def gg(xx): print "gg called" def s(y): return y-1 return s @gg # ← this is decorator def ff(x): print "ff called" return x+1 print ff(3) # output: # gg called # 2
Note: the wrapper function
gg receives the function
ff. The wrapper can do anything with it. Typically, it'll eventually call
ff, but it doesn't have to.
In the above example, the wrapper
gg bypass
ff entirely.
Here's 4 things to remember when writing a decorator:
gmust take a function as argument. (because it'll receive
fas argument.)
gmust return a function. (because that'll be applied to
f's arguments.)
hmust take the same number/type of arguments as
f.
hshould return the same type of value that
freturns. If
freturns a string,
hprobably should too. If
freturns
None,
hprobably should too.
Here's a example of decorator. It (in effect) modifies the function's argument.
# -*- coding: utf-8 -*- # python # example of a decorator def gg(func): """a decorator for ff. Make sure input to ff is always even. If not, add 1 to make it even""" def hh(y): if y % 2 == 0: # even return func(y) else: return func(y+1) return hh @gg def ff(x): return x print ff(3) # 4 print ff(4) # 4 print ff(5) # 6 print ff(6) # 6
Note: decorator function
gg does not know what the decorated function
ff's arguments. However, since
gg is a wrapper, it can create and return a new function
hh, and have
hh check arguments then call
ff(args). This works because whatever arguments passed to the original function
ff is passed to
hh, then
hh can do arg checking, then call
ff.
When defining the decorator function, often you need to catch all possible arguments of the original function. Here's a example of how.
In the following example, the original function is called only if some global variable is true.
# -*- coding: utf-8 -*- # python # example of decorator that check condition to decide whether to call cc = True # ← the condition def gg(func): """a decorator for ff. If cc is true, run ff, else do nothing""" def hh(*args, **kwargs): # ← param must catch all args of ff """do nothing function""" pass if cc: return func else: return hh @gg def ff(*args, **kwargs): # ff can be sending email, or any callable with no return value print "ff" pass ff(3) ff(3,"Jane") ff(3,4, k="thank you") # if cc is true, then ff is called 3 times # (different set of arguments are used, to illustrate that our wrapper work well with them) # if cc is false, Nothing's done, ff is not called.
〔➤ Python: Function with Optional Parameter, Named Parameter, Infinite Parameters〕
Decorator itself can have parameters.
For example, the following decorator:
@g(3) def f(): print("xyz")
is equivalent to
def f(): print("xyz") f = g(3)(f)
There's nothing special about this. In the simplest decorator example,
@g followed by
def f: gets transformed into
f = g(f). Now, if we replace
g by
g(x), we get
f = g(x)(f).
Decorators can get complex, because it's transforming code and doing function applications and involves nested functions. In this case, just remember that:
g(x)must return a function, let's call it
h1. This will receive
fas argument.
h1must take a function. (
h1will receive
fas argument.)
h1must return a function (let's call it
h2), because
h2will receive
f's argument(s).
Here's a example:
# -*- coding: utf-8 -*- # python # example of decorator with argument def gg(num): """a decorator for ff. Ignore ff. Simply return num.""" def h1(f1): def h2(f2): return num return h2 return h1 # gg(1) must return a function h1, such that h1 accept function (the ff), and also return a function (to be applied to ff's args) @gg(1) def ff(x): return repr(x) + " rabbits" print ff(3) # 1 print ff(4) # 1 print ff(5) # 1 | http://xahlee.info/perl-python/python_decorator.html | CC-MAIN-2015-06 | en | refinedweb |
TestAPI
CoreMVVM
XamlPadX
Xaml Compliance
Dependency property is a pretty kewl concept. You got to agree on that J. One the nice features is the ability to listen to the changes in these properties and I tend to use it a lot. The SDK way would be to derive from the control, override the dependencyproperty metadata and specify the propertychangedCallback in the signature. Hmmm… pretty cumbersome you would say.
public class MyTextBox : TextBox
{
public MyTextBox():base()
{
}
static MyTextBox()
FlowDirectionProperty.OverrideMetadata(typeof(MyTextBox), new FrameworkPropertyMetadata(new PropertyChangedCallback(FlowDirectionPropertyChanged)));
private static void FlowDirectionPropertyChanged(DependencyObject sender, DependencyPropertyChangedEventArgs args)
((MyTextBox)sender).FontWeight = (((MyTextBox)sender).FlowDirection == FlowDirection.RightToLeft) ? FontWeights.Bold : FontWeights.Normal;
}
But hey, things get easy, thanks to Ben. What you can do is use the DependencyPropertyDescriptor.
DependencyPropertyDescriptor dpd = DependencyPropertyDescriptor.FromProperty(DependencyProperty, typeof(Control)));if (dpd != null){ dpd.AddValueChanged(ControlInstance, delegate { // Add property change logic. });}
So, as an example I just tried the following on a textbox. You change the flowDirection (Ctrl and Left Shift) and the text gets bold.... and yeah you need to have some RTL language such as Arabic installed. By default only English comes installed :)
DependencyPropertyDescriptor dpd = DependencyPropertyDescriptor.FromProperty(TextBox.FlowDirectionProperty, typeof(TextBox));if (dpd != null){ dpd.AddValueChanged(tb, delegate { tb.FontWeight=(tb.FlowDirection==FlowDirection.RightToLeft)?FontWeights.Bold:FontWeights.Normal;
});}
That makes life a lot easier… doesn’t it!!
This is part of .net 3.0.
You should have mentioned it.
Hi Mark,
Thats a good point.. It is however mentioned in the tags :)
Appunti di WPF: Un po di link utili
Maybe not the best title to describe the post. Anyway, I was looking at some of the apps the other... | http://blogs.msdn.com/b/llobo/archive/2007/03/05/listening-to-dependencyproperty-changes.aspx | CC-MAIN-2015-06 | en | refinedweb |
We noticed several early adopters running into an issue with the build service in TFS11 Beta stopping unexpectedly. There is no event log entry other than it stopped and restarting it seems to work fine. The root cause seems to be connectivity to the TFS11 application tier. If the build machine can't connect to the AT for more than the 5 minute timeout, an exception causes it to stop. It acutally stops normally, so the service failure configuration doesn't restart it. We also forgot to log the error to the event log, so there's no explanation for the stoppage.
The only workaround is to restart the service.
To make this a little easier, I wrote a simple console application that will check the service every five minutes and ensure that it is still running. Unfortunately, this application has to run as an administrator because of the security around services. Simply create a Windows Console Application in VS, add a reference to System.ServiceProcess for the project,and replace Program.cs with this code...
using System; using System.Collections.Generic; using System.Diagnostics; using System.Linq; using System.ServiceProcess; using System.Text; using System.Threading; using System.Threading.Tasks; namespace KeepAliveBuildService { class Program { static void Main(string[] args) { String serviceName = args.Length > 0 ? args[0] : "TfsBuildServiceHost.2012"; while (true) { // Make sure the service is up EnsureServiceIsStarted(serviceName); // Wait five minutes Thread.Sleep(new TimeSpan(0, 5, 0)); } } static bool EnsureServiceIsStarted(String serviceName) { try { var service = new ServiceController(serviceName); LogMessage(String.Format("{0} Status {1}", serviceName, service.Status)); if (service.Status != ServiceControllerStatus.Running) { LogMessage(String.Format("Starting {0}", serviceName, service.Status)); service.Start(); return true; } } catch (InvalidOperationException) { LogMessage(String.Format("No service with the name {0} could be found.", serviceName)); } catch (Exception ex) { LogMessage(ex.ToString()); } return false; } static void LogMessage(String message) { String source = "KeepAliveBuildService"; String log = "Application"; if (!EventLog.SourceExists(source)) { EventLog.CreateEventSource(source, log); } EventLog.WriteEntry(source, message); Console.WriteLine(message); } }}
You can run the program interactively on the desktop (remember to run as Admin) or you can create a Windows Service torun the application for you.Please note that this is only a problem for the TFS11 Beta Build Service. We have since fixed the problem and it should not appear in future versions
Sorry about the bug :( | http://blogs.msdn.com/b/jpricket/archive/2012/05/08/tfs11-beta-tfsbuildservicehost-2012-service-stopping-unexpectedly.aspx | CC-MAIN-2015-06 | en | refinedweb |
You can subscribe to this list here.
Showing
2
results of 2
Hi
The following stylesheet:
<xsl:stylesheet
xmlns:xsl="";
<xsl:template
<xsl:copy>
<xsl:apply-templates
</xsl:copy>
</xsl:template>
<xsl:template
<xsl:namespace
<xsl:fallback>
<fallback/>
</xsl:fallback>
</xsl:namespace>
</xsl:template>
</xsl:stylesheet>
produces the following error:
$ saxon xsl-nam*.xml xsl-nam*.xsl
Error at xsl:namespace on line 12 of xsl-namespace.xsl:
XTSE0910: An xsl:namespace element with a select attribute
must be empty
Failed to compile stylesheet. 1 error detected.
But XTSE0910 says:
.
It seems to be a bug?
Regards,
--drkm
___________________________________________________________________________
I've done a few experiments and I have to say I'm pretty shocked by the fact
that the behaviour of the various Java routines seems to be completely
unpredictable when given URIs containing invalid percent-encoding sequences.
The java.net.URI constructors apparently don't complain; conversion to a URL
doesn't complain; but dereferencing the URL using openConnection() or
openStream() throws arbitrary errors such as StringOutOfBoundsException,
IndexOutOfBounds, or IllegalArgumentException, etc.
The lazy solution would be to do a general catch of these unchecked
exceptions and assume that they mean "invalid URI". I can't say I like that
approach much.
There doesn't seem to be any method in Java for validating the
percent-encoding, either. There's a URLDecoder class, but the specification
explicitly says that you can't rely on it to detect invalid escape
sequences. I think I may have to write my own decoder.
Please note that 'file%20%C1' should be an error. If characters are
percent-encoded, then they should be encoded using the hex representation of
the octets of the UTF-8 encoding of the character. C1 is not the UTF-8
encoding of any character, so it is not allowed.
It doesn't particularly worry me that there are some URIs which when
dereferenced give you a directory listing. The mapping of URIs to the
contents of filestore is entirely platform-dependent. It would be nice if it
were well documented, but beyond that, I think one has to accept that the
system can do what it likes.
The use of "+" to mean space is not a general feature of URI encoding. It's
specific, I believe, to the HTTP protocol, and therefore has no place in
this interface.
Michael Kay
> -----Original Message-----
> From: saxon-help-bounces@...
> [mailto:saxon-help-bounces@...] On Behalf
> Of Abel Braaksma
> Sent: 12 January 2007 16:49
> To: Mailing list for SAXON XSLT queries
> Subject: Re: [saxon] More meaningful error for "Fatal error
> during transformation: null"
>
> Michael Kay wrote:
> > Looks to me as if java.net.URL.openStream() has returned an
> > IllegalArgumentException, which isn't really supposed to
> happen when
> > you call a method with no arguments; there's certainly no
> clue in this
> > exception as to what's actually wrong, it's not an error condition
> > documented in the spec of the Java method. In this
> situation, there's
> > very little Saxon can do other than showing the stackTrace. If it
> > can't read the file, then it's supposed to throw an IOException.
> >
> > I don't think it makes sense for Saxon to catch unchecked
> exceptions
> > thrown by Java system calls unless it's clearly documented
> that this
> > is an expected behaviour. For the moment, let's concentrate on
> > discovering (a) what the circumstances are under which this
> happens,
> > and (b) whether the Java runtime is actually behaving as it should.
> >
> > The "null" in the final message is purely because
> getMessage() on the
> > IllegalArgumentException returns null. I can only improve that
> > cosmetically, I can't actually provide any extra
> information because
> > Java hasn't supplied any.
>
> I found a hidden feature in your Saxon, I believe: retrieving
> directory contents does not require an extension function,
> you can do that easily (see below) from plain legal XSLT (in
> Saxon, that is).
>
> After spending some hours on this, I came to realize that it
> must be something very tiny and very odd. Then I decided to
> do some comparisons of my CVS history and Local History and
> came to the conclusion that I used an incorrect escape
> sequence (simple typo) in the url.
>
> I got curious and did some tests. You may be suprised of the
> results (I was!). Note that none of the urls exist in reality.
>
> <xsl:stylesheet
> xmlns:
>
> <xsl:template
>
> <!-- (A) index out of range: 99 -->
> <xsl:value-of
> <xsl:value-of
>
> <!-- (B)index out of range: 102 -->
> <xsl:value-of
> <xsl:value-of
>
> <!-- (C) null -->
> <xsl:value-of
>
> <xsl:value-of
> <xsl:value-of
>
> <!-- (D) returns true()!!! -->
> <xsl:value-of
> <xsl:value-of
>
> <!-- (E) returns content of current directory!!! -->
> <xsl:value-of
> <xsl:value-of
>
> <!-- (F) returns content of parent-parent directory -->
> <xsl:value-of
>
> <!-- (G) Failed to load document %20%00 -->
> <xsl:value-of
>
> <!-- (H) The filename, directory name, or volume
> label syntax is incorrect -->
> <xsl:value-of
>
> </xsl:template>
> </xsl:stylesheet>
>
>
> From what I know of the specs, the input to these functions
> must be a valid URI. Some of the above clearly are not. I
> propose a little improvement where the input argument to
> these functions is checked for being a legal URI. If not, a
> formal error can be raised, like : "First argument of xxx is
> not a valid URI".
>
> I was also a little surprised that "legal" escape sequences
> above xA0 did not work and raise an Index Out Of Bound error.
> I thought these were allowed in URIs. But perhaps these are
> excluded for security reasons?
>
> Apparently %00 is allowed but ignored. Not sure why that is.
> Security again? I'd vote for disallowing, like any other below %20.
>
> Finally, I missed the feature that a '+' sign should be
> interpreted as a space (which wasn't) and that a space in
> itself is allowed (which shouldn't be).
>
> Regards,
> -- Abel Braaksma
>
>
> --------------------------------------------------------------
> -----------
> Take Surveys. Earn Cash. Influence the Future of IT Join
> SourceForge.net's Techsay panel and you'll get the chance to
> share your opinions on IT & business topics through brief
> surveys - and earn cash
>
> &CID=DEVDEV
> _______________________________________________
> saxon-help mailing list
> saxon-help@...
> | http://sourceforge.net/p/saxon/mailman/saxon-help/?viewmonth=200701&viewday=13 | CC-MAIN-2015-06 | en | refinedweb |
This document provides information on the Run > Run on Server menu item,
including how it works, and how to make it appear or disappear on a given
object.
The Run, Debug, and Profile menu items are contributed by the Eclipse debug
component. These menus appear on all objects in the UI that are adaptable to
org.eclipse.debug.ui.actions.ILaunchable. Enabling these menus (by adapting
objects to ILaunchable) is a prerequisite to enabling Run on Server.
If the Run menu appears on something that is not runnable, one solution is
to try to remove the ILaunchable adapter to remove the menu entirely.
To determine when the Run on Server submenu appears in the Run menu, the
org.eclipse.wst.server.ui.moduleArtifactAdapters extension point is used.
This extension point provides an enablement expression that allows other
plugins to enable the Run on Server submenu for specific objects.
The Run on Server menu item appears on all objects that are accepted by
at least one moduleArtifactAdapters expression.
Once the Run on Server menu item is selected, the selected object is
adapted to IModuleArtifact. If the object cannot be adapted, an error
message will be displayed (this should never happen unless an external
plugin provides enablement but not adapting for an object). If the object
can be adapted, Run on Server will proceed to try to find an available
server to run on.
The most common problems with Run on Server are it not appearing
on objects that should be runnable, or appearing on objects that aren't
runnable:
This problem occurs when the selected object cannot be adapted (either
directly or via an adapter factory) to ILaunchable. The owner of the
object should provide an adapter to make the menu appear.
This problem occurs when the selected object is incorrectly adaptable to
ILaunchable. The owner of the object should remove the ILaunchable interface
or the adapter factory that supports the object.
Is Run on Server not appearing on an object that you think is runnable?
Contact the development team responsible for the artifact (e.g. J2EE team
for Servlet) and ask them to add support.
This problem can only occur when some plugin is using the moduleArtifactAdapter
extension point to enable for an object that it shouldn't. Use the steps below
to figure out which plugin is causing the problem and open a defect up against
them.
Using a development environment, turn on tracing for org.eclipse.wst.server.ui
and launch a workbench. When you right click on the object and hover over the
Run menu, the following line of trace will be output as Run on Server appears:
"Run On Server for XX is enabled by YY." XX is the object that you have selected,
and YY is the extension point id for the plugin that is doing the enablement.
Track down the id and open a defect against this component.
This problem can only occur when a plugin provides enablement for an object
but does not allow the object to adapt to IModuleArtifact. Use the tracing
steps above to identify the plugin and open a defect to get the object adapted.
The appendix contains some useful hints and tips.
Enablement expressions allow you to create arbitrarily complex expressions using ands, ors,
nots, and Java code. For performance reasons, it's always better to use the expression
support instead of using Java code, which is slower or may be in plugins that aren't loaded
yet. However, simple Java tests can provide much better flexibility and do not need to
cause large delays.
The best practice is to use enablement expressions as much as possible to filter down the
number and types of objects that are applicable. As a final check, a property tester can
then be used. However, it is still important to use expressions first, even if you know
you'll be using a property tester for the last check - this will keep the performance up
for all the objects that are filtered out.
To add a property tester to an enablement expression, try using the following example.
In your plugin.xml, add the propertyTesters extension point:
<extension point="org.eclipse.core.expressions.propertyTesters">
<propertyTester
id="org.eclipse.myplugin.propertyTester"
namespace="org.eclipse.myplugin"
properties="someProperty"
type="java.lang.Object"
class="org.eclipse.myplugin.internal.MyPropertyTester">
</propertyTester>
</extension>
package org.eclipse.myplugin.internal;
import org.eclipse.core.expressions.PropertyTester;
public class MyPropertyTester extends PropertyTester {
public boolean test(Object receiver, String property, Object[] args, Object expectedValue) {
// cast receiver and/or expectedValue
// if (xx) // check some dynamic property
return true;
// else
//return false;
}
}
<test property="org.eclipse.myplugin.someProperty" value="true"/> | http://www.eclipse.org/webtools/wst/components/server/runOnServer.html | CC-MAIN-2015-06 | en | refinedweb |
30 December 2008 11:09 [Source: ICIS news]
LONDON (ICIS news)--Braskem will shut its polyethylene teraphthalate (PET) unit by the end of the year as it is not viable to produce the product on a competitive basis, the Brazilian petrochemicals company said late on Monday.
The closure of the unit, at Camacari, would not lead to any job losses and Braskem would ensure the supply of PET resin until at least April 2009, it said in a statement.
Braskem announced the deactivation of its dimethyl terephthalate (DMT) production unit and the temporary suspension of PET production in May 2007.
A study to assess the possibility of resuming PET production using a new technological approach found it would not be competitive. The unit's closure marks Braskem's exit from the PET business.
“The decision was grounded in Braskem’s focus on prioritising investments that provide the company with returns above the cost of capital and that are aligned with its business strategy,” Braskem said.
“This decision will result in the constitution of an accounting provision [with no cash impact] of approximately reais (R) 125m ($53m)."
Braskem describes itself as the leading company in the thermoplastic resins industry in Latin America and the third-largest resin producer in the ?xml:namespace>
($1 = R | http://www.icis.com/Articles/2008/12/30/9181106/brazils-braskem-to-shut-camacari-pet-unit-by-year-end.html | CC-MAIN-2015-06 | en | refinedweb |
Subsets and Splits