Unreal Wiki - User contributions [en]

Interfaces

2008-05-06T19:12:39Z

Azrael: Redirecting to Interface

#REDIRECT [[Interface]]

Sandbox

2008-05-06T19:11:37Z

Azrael: Redirecting to Unreal Wiki:Sandbox

#REDIRECT [[Unreal Wiki:Sandbox]]

Legacy:Set Up Package Folders

2008-05-06T17:42:17Z

Azrael: Made the list not suck.

''This is a [[:Category:Legacy Basic Procedure]] tutorial page. It explains how to perform a single procedure which is required in many different contexts.''

The first step in [[Legacy:Making Mods|making mods]] or creating any sort of script that will be compiled into a .U file (a [[Legacy:Package|package]]) is setting up package folders. This is just a small hierarchy of folders within your game's [[Legacy:Base Directory|Base Directory]]. Source code ([[Legacy:UC File|UC file]]s) and resources such as textures and models go into these folders. The Unreal Engine compiler, [[Legacy:Ucc|Ucc]], will then know to make them into the final package that the game can then execute.

==The main folder ==

This folder must be inside your game [[Legacy:Base Directory|Base Directory]], and the name of this must match the name of your eventual package. For example,
: {[[Legacy:Base Directory|Base Directory]]}\YourModPackage

When [[Legacy:Ucc|Ucc]] compiles, it will know that this folder must be used to make YourModPackage.U from what it finds inside the folder.

Choose a name for your package that clearly describes your project.

==Sub-folders==

Within this folder, you need subfolders, one for each type of resource. If you don't have any of a particular resource, you don't need the folder.

; {[[Legacy:Base Directory|Base Directory]]}\YourModPackage\Classes : This is the directory that should hold all of your [[Legacy:UC File|UC file]]s. This is mandated by the compiler itself. Your code will not be built if you use anything else.
; {[[Legacy:Base Directory|Base Directory]]}\YourModPackage\Textures : This directory should be used to hold any HUD textures, object skins, and other graphics used by your mod.
; {[[Legacy:Base Directory|Base Directory]]}\YourModPackage\Models : This is where you put the *.3d files for any meshes your classes import and use.
; {[[Legacy:Base Directory|Base Directory]]}\YourModPackage\Sounds : This directory should be used to store any custom sounds used by your mod.

It is advisable to store a copy of your mod's [[Legacy:INT File|INT file]] in the {[[Legacy:Base Directory|Base Directory]]}\YourModPackage directory for safekeeping.

==Conclusion==

When you are finished, you should have a folder tree like this:

+ BaseDirectory
++ YourModPackage
+++ Classes
+++ Textures
+++ Models
+++ Sounds
++ Some other game directory
++ etc...

==Related Topics==
* [[Legacy:UnrealScript Lessons|UnrealScript Lessons]]
* [[Legacy:Compiling With UCC|Compiling With UCC]]

==Discussion==

'''SuperApe:''' Not sure where this "tip" should go, but I noticed that package names matter. A reference to a texture in FOO.utx can bork from an actor in FOO.u because the base name of the package is the same. Specifically, this was a gameinfo screenshot reference and I had to change the texture package name to FOOtex.utx before the gameinfo actor could see the screenshot. Other textures referenced from the main package worked fine, but the gameinfo screenshot was problematic.
[[Category:Legacy Basic Procedure|{{PAGENAME}}]]

Template talk:Infobox class

2008-05-05T12:50:40Z

Azrael: New page:

User:Azrael

2008-05-05T12:48:46Z

Azrael: New page: I'm gorgeous and incredibly strong.

I'm gorgeous and incredibly strong.

Unreal Tournament 3

2008-05-05T12:47:35Z

Azrael:

UT3

2008-05-05T12:47:25Z

Azrael: Redirecting to Unreal Tournament 3

#REDIRECT [[Unreal Tournament 3]]

Template:Softredirect

2008-05-05T12:47:06Z

Azrael:

[[Image:Redirectltr.png|#REDIRECT ]][[{{{1}}}]] This page is a [[Wikipedia:Soft redirect|soft redirect]].<includeonly>[[Category:Soft redirects|{{PAGENAME}}]]</includeonly>

Unreal Tournament 2003

2008-05-05T12:46:38Z

Azrael:

UT2003

2008-05-05T12:46:25Z

Azrael: Redirecting to Unreal Tournament 2003

#REDIRECT [[Unreal Tournament 2003]]

Unreal Tournament 2004

2008-05-05T12:46:08Z

Azrael:

UT2004

2008-05-05T12:45:23Z

Azrael: Redirecting to Unreal Tournament 2004

#REDIRECT [[Unreal Tournament 2004]]

Unreal Wiki:Sandbox

2008-05-05T12:44:49Z

Azrael:

Do not edit the area above the separator line, please.

----
==Variables==
*{{variable|int|awesomeness}}
*{{variable|array|awesome_people|Pawn}}

==Link replacement with #replace==
* This correctly replaces, but for obvious reasons doesn't produce links correctly: [[{{#replace:a,b,c|,|]], [}}]]
* This doesn't even apply #replace: [[{{#replace:a,b,c|,|]], [[}}]]
* This works, but is very ugly: {{#replace:{{#replace:@@{{#replace:a,b,c|,|~~, @@}}~~ | ~ | ] }} | @ | [ }}
* Still ugly, but definitely better: [[{{#replace:a,b,c|,|{{concat|]|], [|[}}}}]]

==Trees==
+erergtsdg
++dfgsdfg
+++dfgsdfg
++sdfgsdfgdfg
+++sdfgsdfgsdfg
+++sdfgdsfgsdfg
++++sdfgs dfgsdfgsdfg
++dsfgdsfg
+++sdfgsdfg
++sdgsdfgs

==Interwiki testing==
* [[JDN:JBInfoJail]]
* [[WikiPedia:Unreal Tournament|UT]]
* [[Liandri:UT2004]]

----

{{Infobox class
| class = UTCheatManager
| package = UTGame
| within = PlayerController
| game = UT3
| engine = UE3
| parent1 = Object
| parent2 = CheatManager
}}

{{infobox class part
| class = PlayerController
| package = UTGame
| game = UT3
| engine = UE3
| parent1 = Object
}}

<dpl>
category = Custom UE2-specific classes
include={Infobox class}:parent1
includematch=/./
secseparators= \n- Subclass of ,
</dpl> 

<categorytree mode=pages style="float:left; clear:left; margin-left:1ex; border:1px solid gray; padding:0.7ex; background-color:white;">Custom UE2-specific classes</categorytree> 

{{category within classes|Object|UT3|Unreal Tournament 3}}
{{category package classes|Engine|UT3|Unreal Tournament 3}}
{{package classes|Engine|UT3|Unreal Tournament 3}}

http://wiki.beyondunreal.com/Special:CategoryTree?target=UT2004-specific_classes&mode=20

<categorytree mode=pages style="float:left; clear:left; margin-left:1ex; border:1px solid gray; padding:0.7ex; background-color:white;">Custom UE2-specific classes|Engine</categorytree> 
<categorytree mode=pages style="float:left; clear:left; margin-left:1ex; border:1px solid gray; padding:0.7ex; background-color:white;">[[category within classes|UIObject|UT3|Unreal Tournament 3]]</categorytree> 

{{#categorytree:game classes|UT3|Unreal Tournament 3|depth=0|mode=pages}}

{{#categorytree:Classes in UT3 package Engine|Engine|UT3|Unreal Tournament 3|depth=0|mode=pages}} 
[[{{#categorytree:Classes in UT3 package Engine|,|Classes in UT3 package GameFramework|depth=1|mode=pages}}]]

{{#categorytree:Custom UE2-specific classes|{{{Infobox class}:parent1}}|hideroot|mode=pages}} 

<categorytree mode=pages depth=0 style="float:left; clear:left; margin-left:1ex; border:1px solid gray; padding:0.7ex; background-color:white;">Custom UE2-specific classes</categorytree> 

{{todo|What to do|who1,who2,etc|project=proj1,proj2,etc}} 
----

=Lorem Ipsum=
"Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum." 

==What is Lorem Ipsum?==
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum. 

===Where Does it Come from?===
:Contrary to popular belief, Lorem Ipsum is not simply random text. It has roots in a piece of classical Latin literature from 45 BC, making it over 2000 years old. Richard McClintock, a Latin professor at Hampden-Sydney College in Virginia, looked up one of the more obscure Latin words, consectetur, from a Lorem Ipsum passage, and going through the cites of the word in classical literature, discovered the undoubtable source. Lorem Ipsum comes from sections 1.10.32 and 1.10.33 of "de Finibus Bonorum et Malorum" (The Extremes of Good and Evil) by Cicero, written in 45 BC. This book is a treatise on the theory of ethics, very popular during the Renaissance. The first line of Lorem Ipsum, "Lorem ipsum dolor sit amet..", comes from a line in section 1.10.32.

:The standard chunk of Lorem Ipsum used since the 1500s is reproduced below for those interested. Sections 1.10.32 and 1.10.33 from "de Finibus Bonorum et Malorum" by Cicero are also reproduced in their exact original form, accompanied by English versions from the 1914 translation by H. Rackham.
====Section 1.10.32 of "de Finibus Bonorum et Malorum", written by Cicero in 45 BC====
:"Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo. Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt. Neque porro quisquam est, qui dolorem ipsum quia dolor sit amet, consectetur, adipisci velit, sed quia non numquam eius modi tempora incidunt ut labore et dolore magnam aliquam quaerat voluptatem. Ut enim ad minima veniam, quis nostrum exercitationem ullam corporis suscipit laboriosam, nisi ut aliquid ex ea commodi consequatur? Quis autem vel eum iure reprehenderit qui in ea voluptate velit esse quam nihil molestiae consequatur, vel illum qui dolorem eum fugiat quo voluptas nulla pariatur?"
=====1914 translation by H. Rackham=====
:"But I must explain to you how all this mistaken idea of denouncing pleasure and praising pain was born and I will give you a complete account of the system, and expound the actual teachings of the great explorer of the truth, the master-builder of human happiness. No one rejects, dislikes, or avoids pleasure itself, because it is pleasure, but because those who do not know how to pursue pleasure rationally encounter consequences that are extremely painful. Nor again is there anyone who loves or pursues or desires to obtain pain of itself, because it is pain, but because occasionally circumstances occur in which toil and pain can procure him some great pleasure. To take a trivial example, which of us ever undertakes laborious physical exercise, except to obtain some advantage from it? But who has any right to find fault with a man who chooses to enjoy a pleasure that has no annoying consequences, or one who avoids a pain that produces no resultant pleasure?"
:====Section 1.10.33 of "de Finibus Bonorum et Malorum", written by Cicero in 45 BC==== '''want to indent the heading'''
:"At vero eos et accusamus et iusto odio dignissimos ducimus qui blanditiis praesentium voluptatum deleniti atque corrupti quos dolores et quas molestias excepturi sint occaecati cupiditate non provident, similique sunt in culpa qui officia deserunt mollitia animi, id est laborum et dolorum fuga. Et harum quidem rerum facilis est et expedita distinctio. Nam libero tempore, cum soluta nobis est eligendi optio cumque nihil impedit quo minus id quod maxime placeat facere possimus, omnis voluptas assumenda est, omnis dolor repellendus. Temporibus autem quibusdam et aut officiis debitis aut rerum necessitatibus saepe eveniet ut et voluptates repudiandae sint et molestiae non recusandae. Itaque earum rerum hic tenetur a sapiente delectus, ut aut reiciendis voluptatibus maiores alias consequatur aut perferendis doloribus asperiores repellat."
:=====1914 translation by H. Rackham===== '''want to indent the heading'''
:"On the other hand, we denounce with righteous indignation and dislike men who are so beguiled and demoralized by the charms of pleasure of the moment, so blinded by desire, that they cannot foresee the pain and trouble that are bound to ensue; and equal blame belongs to those who fail in their duty through weakness of will, which is the same as saying through shrinking from toil and pain. These cases are perfectly simple and easy to distinguish. In a free hour, when our power of choice is untrammelled and when nothing prevents our being able to do what we like best, every pleasure is to be welcomed and every pain avoided. But in certain circumstances and owing to the claims of duty or the obligations of business it will frequently occur that pleasures have to be repudiated and annoyances accepted. The wise man therefore always holds in these matters to this principle of selection: he rejects pleasures to secure other greater pleasures, or else he endures pains to avoid worse pains." 
==Why do we use it?==
It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout. The point of using Lorem Ipsum is that it has a more-or-less normal distribution of letters, as opposed to using 'Content here, content here', making it look like readable English. Many desktop publishing packages and web page editors now use Lorem Ipsum as their default model text, and a search for 'lorem ipsum' will uncover many web sites still in their infancy. Various versions have evolved over the years, sometimes by accident, sometimes on purpose (injected humour and the like). 
==Where can I get some?==
There are many variations of passages of Lorem Ipsum available, but the majority have suffered alteration in some form, by injected humour, or randomised words which don't look even slightly believable. If you are going to use a passage of Lorem Ipsum, you need to be sure there isn't anything embarrassing hidden in the middle of text. All the Lorem Ipsum generators on the Internet tend to repeat predefined chunks as necessary, making this the first true generator on the Internet. It uses a dictionary of over 200 Latin words, combined with a handful of model sentence structures, to generate Lorem Ipsum which looks reasonable. The generated Lorem Ipsum is therefore always free from repetition, injected humour, or non-characteristic words etc.

===Here?===
:Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Maecenas feugiat, turpis nec faucibus pellentesque, ligula enim auctor diam, rutrum vehicula ante est ac augue. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Nullam eget justo dignissim erat consectetuer euismod. Praesent ultricies. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Mauris accumsan erat in lectus. Praesent elementum rutrum mi. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Proin a nulla. Sed consectetuer, nisi a dapibus aliquam, arcu nunc lacinia metus, eget sodales nulla turpis non mi. Aenean eget dolor. In venenatis lacus sit amet augue. Maecenas faucibus. Sed leo. Vestibulum posuere neque eu tortor. Aenean et arcu. Aenean quis turpis. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Sed eget nisi. Nam justo nisl, varius quis, facilisis at, dignissim eget, tellus.
====or Here?====
::Praesent lacinia tortor ac felis. Vivamus varius, quam et ultricies tristique, neque ante scelerisque leo, id volutpat purus augue in ipsum. Vivamus consectetuer, pede eu vehicula vulputate, sem nisi commodo risus, quis sagittis elit enim sed pede. Quisque eget justo. Etiam nec nisl in magna sagittis fermentum. Ut velit. Sed pulvinar pellentesque purus. Quisque venenatis, justo at consequat suscipit, dolor lorem lacinia mi, sed auctor risus elit et dui. Duis ante dui, molestie facilisis, feugiat et, bibendum vel, nibh. Vivamus mi augue, eleifend nec, euismod sit amet, placerat quis, tortor. Sed congue neque a quam blandit laoreet.
====or even Here?====
::Vestibulum porttitor ante et nunc. Nunc nec libero. Mauris consequat, est in facilisis laoreet, mi ligula accumsan elit, ut scelerisque risus felis sit amet nibh. Donec ornare ipsum a dui. Maecenas sagittis, sem at commodo ultrices, lacus eros lobortis arcu, vel dapibus odio felis quis tellus. Fusce justo ante, sollicitudin vulputate, vulputate eu, aliquam a, odio. Morbi nisi. Integer at urna. Mauris dolor est, aliquet sit amet, congue sed, placerat ac, enim. Proin a velit at enim vulputate luctus. Phasellus placerat augue egestas dolor. Integer justo tellus, porta ac, varius ac, semper rhoncus, mauris. Morbi vulputate ultricies sem. Vestibulum at sapien. Nulla nec est. Vivamus aliquet mi vel augue. Duis sed turpis id dui sagittis facilisis. Nulla neque sapien, dapibus a, laoreet fringilla, vestibulum eget, dui. Suspendisse potenti.

::*'''Perhaps here?'''
::**Suspendisse varius venenatis tortor. Nullam sit amet orci. Mauris mattis lacus at sem. Sed eu arcu quis mauris congue egestas. Nam varius blandit ipsum. Ut eu est id risus dignissim facilisis. Integer eget lectus. Suspendisse tincidunt nisl sed eros. Aliquam iaculis cursus lacus. Mauris neque. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas.
::*'''Perhaps even here?'''
::**Nam a nulla vitae lacus facilisis imperdiet. Mauris nulla tortor, aliquam vel, congue non, iaculis nec, nunc. Proin eleifend est luctus nisl. Vivamus pellentesque. Vivamus rhoncus est ac justo. Aliquam eleifend, purus vel elementum malesuada, purus tortor venenatis erat, ut hendrerit purus arcu et mauris. Nunc eu justo id nibh pharetra fermentum. Duis vestibulum adipiscing risus. Curabitur quis neque sit amet odio sollicitudin cursus. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas.

Byte

2008-05-05T12:37:27Z

Azrael: Redirecting to Types#Byte

#REDIRECT [[Types#Byte]]

Int

2008-05-05T12:36:55Z

Azrael: Redirecting to Types#Int

#REDIRECT [[Types#Int]]

Template:Variable

2008-05-05T12:36:00Z

Azrael:

[[{{{1}}}]]{{#if:{{{3|}}}|<[[{{{3}}}]]>|}} {{{2}}}

Template:Variable

2008-05-05T12:35:04Z

Azrael: New page: {{{1}}}{{#if:{{{3|}}}|<{{{3}}}>|}} {{{2}}}

[[{{{1}}}]]{{#if:{{{3|}}}|<{{{3}}}>|}} {{{2}}}

Template:Int

2008-05-05T12:28:47Z

Azrael: New page: int {{{1}}}

[[Types#Int|int]] {{{1}}}

Template:Softredirect

2008-05-05T12:24:51Z

Azrael: New page: #REDIRECT {{{1}}} This page is a [[Wikipedia:Soft red...

File:Redirectltr.png

2008-05-05T12:24:22Z

Azrael: Redirect Image used in Wikipedia.

== Summary ==
Redirect Image used in Wikipedia.
== Licensing ==
{{GFDL}}

Unreal Tournament 2003

2008-05-05T12:19:22Z

Azrael: New page: Information about Unreal Tournament 2003 is available on [http://liandri.beyondunreal.com/Unreal_Tournament_2003 The Liandri Archives].

Information about Unreal Tournament 2003 is available on [http://liandri.beyondunreal.com/Unreal_Tournament_2003 The Liandri Archives].

Unreal Tournament 2004

2008-05-05T12:19:09Z

Azrael: New page: Information about Unreal Tournament 2004 is available on [http://liandri.beyondunreal.com/Unreal_Tournament_2004 The Liandri Archives].

Information about Unreal Tournament 2004 is available on [http://liandri.beyondunreal.com/Unreal_Tournament_2004 The Liandri Archives].

Unreal Tournament 3

2008-05-05T12:18:32Z

Azrael: New page: Information about Unreal Tournament 3 is available on [http://liandri.beyondunreal.com/Unreal_Tournament_3 The Liandri Archives].

Information about Unreal Tournament 3 is available on [http://liandri.beyondunreal.com/Unreal_Tournament_3 The Liandri Archives].

Structs

2008-05-05T12:05:05Z

Azrael: /* Native struct code */

A '''struct''' (or '''structure''') is a composite data type in [[UnrealScript]], that can contain multiple member variables of (almost) any type, including another struct type. Structs are ''not'' reference types, that means a variable of a struct type actually contains the struct data itself, not a reference to the struct data. This imposes an important restriction on struct types: a struct may not directly or indirectly contain a variable of that same struct type.

'''Note:''' The compiler will probably not complain about a struct violating this restriction. However, if the struct type is used to declare any class or local variables or function parameters or return types, the compiler will likely crash as it attempts to allocate an infinite amount of memory!

==Declaration syntax==
The general syntax of a struct declaration is:
'''struct''' ''modifiers'' ''structname'' ['''extends''' ''parentstruct''] '''{'''
...
'''}'''
Like [[enums]], struct declarations may appear either as standalone declaration, in which case they must be followed by a semicolon, or as inline declaration instead of the type specification in variable declarations. Struct declarations may be contained in other struct declarations, both standalone or in variable declarations. There is no difference between declaring a struct at the class level and within another struct or between a standalone and inline declaration, in all cased the struct is a direct member of the class.

Remember that all members of an UnrealScript class share the same namespace. A struct declaration may hide any member of a parent class if it has the same name.

==Modifiers==
Struct modifiers are not available in [[Unreal Engine 1]]. Most struct modifiers are related to native code. Modifers with other uses are:

; long : Specifies that the struct contains many members and should not be examined when generating a value string for struct variables in [[UnrealEd]]'s [[Actor properties window]]. Usually structs like [[Vector]] are displayed as "(X=1.2,Y=3.4,Z=5.6)", but with the '''long''' modifier only "(...)" is displayed.

Other struct modifiers you may encounter but shouldn't use for your own structs are:
; export : This struct is supposed to be exported to native headers.
; immutable : ''?''
; init : ''?''
; native : This struct includes native logic.
; transient : ''?''
; {''native type name''} : The type to use in [[native]] code instead of this struct type. This is mainly a hack in Unreal Engine 3 to declare variables in UnrealScript with types the UnrealScript language does not provide. There are only three instances of this syntax in [[UT3]]. The structs [[UE3:Object (UT3)#qword|Object.qword]] and [[UE3:Object (UT3)#double|Object.double]] represent the native types QWORD and DOUBLE respectively, and the struct [[UE3:UIEditorOptions (UT3)#ViewportDimension|UIEditorOptions.ViewportDimension]] represents the native type WxRect.

==Member declarations==
Struct members are declared like class [[variables]]. A variable group name or certain [[Variables#Modifiers|variable modifiers]] don't make sense for struct members, though.

===Default member values===
By default all struct member variables are initialized with the [[null value]] of the corresponding type.

Starting with [[Unreal Engine 3]], struct members can also have a default value other than the corresponding null value. This can be defined in a [[structdefaultproperties]] block inside the struct declaration. A good example is the [[UE3:Object (UT3)#LinearColor|LinearColor]] struct from [[UT3]]:
<uscript>
// A linear color.
struct immutable LinearColor
{
var() float R, G, B, A;

structdefaultproperties
{
A=1.f
}
};
</uscript>
LinearColor declared four members of type [[float]]. The default value of member '''A''' is defined to be <code>1.0</code>, while all other members keep <code>0.0</code> as their default value. This means, whenever a variable of type LinearColor is declared, its '''A''' component already contains the value <code>1.0</code>, while the '''R''', '''G''', and '''B''' components have the value <code>0.0</code>.

==Native struct code==
Like native classes, some structs in [[Unreal Engine 2]] and 3 games may contain native code snippets in UnrealScript. These declarations do not affect UnrealScript directly, but they are exported when auto-generating native headers while compiling UnrealScript classes. In [[Unreal Tournament 2004|UT2004]] there are only two struct like this, [[UE2:GUI (UT2004)#GUITreeNode|GUI.GUITreeNode]] and [[UE2:GUIMultiColumnList (UT2004)#MultiColumnSortData|GUIMultiColumnList.MultiColumnSortData]]. In Unreal Engine 3 games this is a much more common sight, especially in UI-related classes.

In Unreal Engine 2 native struct code is enclosed in a '''cppstruct''' block. Unreal Engine 3 uses a '''structcpptext''' block instead.

{{navbox unrealscript}}

Template:Samegame/doc

2008-05-05T12:04:30Z

Azrael:

<noinclude>{{Documentation subpage}}</noinclude>
This template generates a page link name for another page in the same namespace and with the same game name in parentheses, if available. It is used mostly on class description pages to avoid content duplication, e.g. between the [[UE2 Runtime]], [[Unreal Tournament 2003|UT2003]] and [[Unreal Tournament 2004|UT2004]] class descriptions.

==Usage==
A link to anchor "Usage" on page "Template:Infobox class" (this namespace!) with the text "Class Infobox":
<pre>[[{{samegame|Infobox class}}#Usage|Class Infobox]]</pre>
[[{{samegame|Infobox class}}#Usage|Class Infobox]]

==See also==
* [[Template:Gamename]]
* [[Template:Classname]]

<includeonly>
[[Category:Utility templates]]
</includeonly>

UnrealScript

2008-05-05T12:03:32Z

Azrael: /* Anatomy of an UnrealScript source file */

:''See [[UnrealScript overview]] for all Unreal Wiki topics about learning and using UnrealScript.''

'''UnrealScript''' is the [[Unreal Engine]]'s [[wp:scripting language|scripting language]]. It is a [[wp:strongly-typed|strongly-typed]], [[wp:object-oriented|object-oriented]] programming language very similar to [[wp:Java (programming language)|Java]] and [[wp:C++|C++]]. If you want to learn UnrealScript, you should make yourself familiar with the fundamental concepts of object-oriented programming. It definitely helps already to know another programming language, preferably one that is strongly-typed and object-oriented as well.

==Anatomy of an UnrealScript source file==
A typical UnrealScript source file might look similar to the following example from [[Unreal Tournament 2004|UT2004]]:
<uscript line>
class DMRosterBeatTeam extends xDMRoster;

/*
* Roster for deathmatch levels.
* Each level has its own roster.
* This special roster subclass is used to populate an enemy team with the
* player's selected teammates.
*/

// called immediately after spawning the roster class
function Initialize(int TeamBots)
{
local GameProfile GP;
local int i, j;

GP = Level.Game.CurrentGameProfile;
if ( GP == none ) {
Log("DMRosterBeatTeam::Initialized() failed. GameProfile == none.");
return;
}

// create roster entries for single player's teammates
for ( i=0; i<GP.PlayerTeam.Length; i++ )
{
j = Roster.Length;
Roster.Length = Roster.Length + 1;
Roster[j] = class'xRosterEntry'.Static.CreateRosterEntryCharacter(GP.PlayerTeam[i]);
}

// remaining team-specific info, might be used in menus at some point
TeamName = GP.TeamName;
TeamSymbolName = GP.TeamSymbolName;

super.Initialize(TeamBots);
}

defaultproperties
{
TeamName="Death Match"
TeamSymbolName="TeamSymbols_UT2003.Sym01"
}
</uscript>
As you can see, UnrealScript is a [[wp:curly brace programming language|curly brace programming language]]: blocks of code are enclosed in curly braces. Each code statement is either followed by a block or terminated by a semicolon.

* Line 1 contains the mandatory [[class declaration]]. This file contains a class with the name [[UE2:DMRosterBeatTeam (UT2004)|DMRosterBeatTeam]]. The [[extends clause]] specifies that this class [[wp:Inheritance (computer science)|inherits]] attributes, methods and other class members from a class with the name [[UE2:xDMRoster (UT2004)|xDMRoster]], which is said to be the "super class" or "parent class" of DMRosterBeatTeam.
* Lines 3 to 8 are an example for a [[Comments#Block comments|block comment]]. The important parts here are the characters <code>/*</code> on line 3 and <code>*/</code> on line 8. Everything between them is ignored by the UnrealScript compiler.
* Line 10 contains another type of comment, an end-of-line comment or just [[Comments#Line comments|line comment]]. Outside of block comments this type of comment starts with the characters <code>//</code> and continues to the end of the same line. As with block comments, everything on the line following the double slashes is ignored by the compiler.
* Line 11 contains a [[Function declarations|declaration]] for an [[instance function]]. The function's name is specified to be "Initialize" and the function has one parameter of type [[types#int|int]] called "TeamBots". The block of code on lines 12 to 35 is the function's "body". Some functions do not have a body. The declaration of those functions is terminated by a semicolon instead.
* The line 13 declares a local variable of [[Types#Object|type]] [[UE2:GameProfile (UT2004)|GameProfile]], a class defined elsewhere, and gives it the name "GP". The variable is initially empty.
* Line 16 assigns a value to the local variable "GP" so it no longer is empty. To determine the value, the function accesses the variable "Level". This variable is not declared here, but in a parent class of DMRosterBeatTeam. The object referenced by "Level" has a variable of its own, called "Game", whose contained object in turn has a variable called "CurrentGameProfile". The content of that variable is assigned to our local "GP" variable.
* On line 17 there's an [[If statement]] with a block of code that ends on line 20. That block of code is only executed if the expression in the parentheses following the keyword ''If'' returns the value ''True''. The ''If'' condition checks, whether the content of the local "GP" variable equals the special value ''None'', which simply means "empty".
* Line 18 and 18 are only executed if the condition (here: "GP is empty") is true. So, if GP is empty, first the function with the name "Log" is called to write a message to the log file, then the [[Return statement]] exits the function. In this case the code after the ''If'' block will not be executed. In other cases the ''If'' block might not contain a ''Return'' and code execution would continue after the ''If'' block.
* On line 23 there's a typical [[For loop]] that iterates over a [[dynamic array]]. The code on lines 25 to 27 is executed for each element of the "PlayerTeam" array in the object stored in the local "GP" variable. Notice how the ''If'' statement on line 17 ensured that "GP" actually contains an object.
* Line 34 calls another version of the "Initialize" function, that was declared in a parent class of DMRosterBeatTeam, passing on the TeamBots parameter. This call tells us, that the "Initialize" function of the DMRosterBeatTeam class actually [[wp:Method overriding (programming)|overrides]] a function with the same name in its parent class xDMRoster or another parent class further up the class hierarchy.
* Lines 37 to 41 are the [[defaultproperties]] block. This block defines default values for class variables. Both "TeamName" and "TeamSymbolName" are inherited from a parent class.

{{navbox unrealscript}}

Literals

2008-05-05T12:03:09Z

Azrael: /* Other ways to specify numbers */

Literals in general are notations that represent a value. This article describes the types of literals available in [[UnrealScript]].

==Numbers==
In UnrealScript, all numeric literals start with a digit. Numeric literals can either stand for an integer or a floating point value and may be prefixed with a minus sign.

===Integer numbers===
The UnrealScript compiler knows two types of integer literals: decimal and hexadecimal. Decimal literals only consist of the decimal digits 0 to 9, while hexadecimal literals start with <code>0x</code>, directly followed by the hexadecimal digits 0 to 9 and A to F. Upper- and lowercase letters can be mixed freely in hexadecimal literals.

'''Examples:'''
:<code>123</code>
:<code>0xC0FFEE</code>
:<code>010</code>

The first example is a typical decimal literal that can represent a [[Types#Byte|byte]] or [[Types#Int|int]] value, while the second example is a hexadecimal literal that exceeds the byte range and definitely stands for a value of type int. The third example is ''not'' octal, but just a decimal literal with a leading zero representing the value ten.

===Float numbers===
[[Types#Float|Floating point]] literals always start with one or more digits, followed by a decimal dot. After the dot, there may be zero or more decimal digits.

'''Examples:'''
:<code>1.0</code>
:<code>123.456</code>
:<code>987.</code>

Note that you can't use the comma as decimal separator, even if that's the standard way to display decimal fractions on your system.

===Other ways to specify numbers===
The compiler recognizes any "glob" consisting of digits, the letters A to F, the letter X and the decimal dot as a number, as long as it starts with a digit. If it contains an X then it's treated as hexadecimal integer literal, if it contains a dot it's treated as floating point literal, otherwise it's a decimal integer literal.

This loose interpretation allows two additional number notations: octal integer literals and scientific floating point literals, the latter only with unsigned exponent, though.
An octal integer literal starts with <code>0</code>, followed by any combination of the octal digits 0 to 7. It also needs to include the letter X, otherwise it will be treated as decimal integer literal.

'''Examples:'''
:<code>0123456789ax</code>
:<code>123456789ax</code>

The first example is interpreted as the value 1234567oct, which is the same as 342391dec. The character 8 is no valid octal digit and thus terminates the value. The compiler takes the entire number glob, sees the X in it and passes it to the generic number parser. That one sees the leading zero, not followed by an X and treats the literal as octal.
The second example contains an X, but does not start with a 0, so it is actually treated as decimal literal and stands for the value 123456789dec. It contains the letter A, but it doesn't start with <code>0x</code>, so it's not a hexadecimal literal and the number parser stops when it arrives at the A.

A scientific floating point literal starts like a normal floating point literal, but after the decimal dot and optional decimal places there's the letter D or E, followed by one or more digits.

'''Examples:'''
:<code>1.5e2</code>
:<code>1.5d2</code>
:<code>1.5e+2</code>
:<code>1.5e-2</code>
:<code>1.f</code>

Only the first two examples actually are actually a single literal. The next two examples really represent the expressions 1.5 +/- 2.0 respectively. The last example can be found quite often in the [[Unreal Tournament 2004|UT2004]] script code and is nothing else than the value 1.0 expressed in a way C++ and Java programmers immediately recognize as a float value. You could, in fact, also write 1.a and it would mean the exact same thing in UnrealScript.

==Boolean values==
[[Types#Bool|Boolean]] literals are quick to explain. There are only two of them, <code>True</code> and <code>False</code>. Both are case-insensitive, like any other identifiers in [[UnrealScript]], so "true" and "tRuE" are the same thing to the compiler.

==Strings==
[[Types#String|String]] literals start and end with double quotes. Between these there may be any number of characters, except line breaks. To include a double quote or backslash character in the string, it must be "escaped" by a(nother) backslash character. Starting with Unreal Engine 3, strings can also contain other escape sequences, such as \n for a newline character. In Unreal Engine 1 and 2 escaped letters only stand for themselves, i.e. the string "\n" is absolutely equal to the string "n" there.

'''Examples:'''
:<code>"abc"</code>
:<code>"This is an \"example\"."
:<code>""</code>

==Names==
[[Types#Name|Name]] literals are similar to strings. They are enclosed in single quotes and may only contain letters, digits and the underscore character. Name literals can't contain escape sequences.

'''Examples:'''
:<code>'RedBase'</code>
:<code>'SniperNest2'</code>
:<code>''</code>

The last example is an empty name, which is often used to spawn actors without a [[Tag]] or to switch to the null [[state]]. It is actually the same as the name literal 'None', but sometimes the empty name makes more sense.

==Enums==
An [[enum]] literal can only be used when specifying a value of an enum type. For example the parameter of the SetPhysics function can be any of the EPhysics values, like <code>PHYS_Falling</code> or <code>PHYS_Projectile</code>.

'''Examples:'''
:<code>PHYS_Walking</code>
:<code>ROLE_SimulatedProxy</code>
:<code>DP_UpperRight</code>
:<code>Request_GET</code>

==Objects==
Generally, an [[Types#Object|object]] literal starts with the unqualified name of an object class, followed by a qualified or unqualified name of an object instance, enclosed in single quotes. These single quotes work slightly different from those of name literals in that there may be whitespace around them. The same goes for the dots between the parts of qualified object names.

'''Examples:'''
:<code>class'Actor'</code>
:<code>Texture 'Engine.WhiteTexture'</code>
:<code>Sound ' Announcer . monsterkill '</code>

The first example is an unqualified literal of type Class representing the [[Actor]] class. The compiler will automatically find out the package containing the class, if it is already loaded. If the package isn't loaded, the lookup will fail. In this case the compiler issues a warning or an error. The second example is a qualified literal of type [[Texture]] representing the WhiteTexture object in the Engine package. Note that WhiteTexture doesn't actually need to be a Texture, but could also be any subclass of Texture, such as [[FireTexture]]. The object literal only specifies the base class and name of the object. The third example represents the monsterkill sound in the Announcer package. Again, this doesn't need to be a [[Sound]] object, but could for example be a [[UE2:SoundGroup (UT2004)|SoundGroup]] object.

There are also two special object literals. The literal <code>None</code> stands for no object. The literal <code>Self</code> can only be used in states and non-static functions and stands for the object instance executing that piece of code.

==Structs==
There are no general [[struct]] literals, but the compiler recognizes literals for vector and rotator constants.

===Vectors===
A [[vector]] literal looks like a function call, but actually represents a constant value. It starts with the keyword <code>Vect</code>, followed by number literals for each of the three components in the order X, Y, Z. The component values are separated by commas and enclosed in round parentheses. You can't use variables or return values of functions here!

'''Example:'''
:<code>vect(0,0,0)</code>
:<code>vect (1.2, 3.4 , 5.6)</code>

The first example is the null vector, i.e. a vector of length zero with an unspecified direction.

===Rotators===
[[Rotator]] literals are similar to vector literals. They start with the keyword <code>Rot</code>, followed by the Pitch, Yaw and Roll components. Like vector components, these are separated by commas and enclosed in round parentheses. Variables and functions are not allowed in rotator literals.

'''Example:'''
:<code>rot(0,0,0)</code>
:<code>rot (1234, 5678 , 9012)</code>

==Functions==
Function literals are only used in [[delegate]] assignments. They consist only of the function name without any special symbols or the keyword <code>None</code> if no function is to be assigned.

{{navbox unrealscript}}

UE2:UT2k4Mod.ini

2008-05-05T12:02:32Z

Azrael:

The '''UT2k4Mod.ini file''' is used when creating a mod using the inbuilt mod system included with [[Unreal Tournament 2004|UT2004]]. It contains descriptions and links to your mod, a logo, and even your mod's url.

When running with the '''-mod=''' command line switch, [[Unreal Tournament 2004|UT2004]] will look for this file in your C:\UT2004\'''YourMod'''; if found it will load the custom '''ini''' file.

{{ambox|type=notice|text= In truth, the content of this file is only referenced by the "User Mods" tab of the community menu. Think of it as the "definition" file for you mod. It contains the the various text and options needed to fill out that menu. – UDN
}}

==General Information on the UT2k4Mod.ini==
;[Mod] : This is the section header and it *MUST* be the first item of your UT2K4MOD.ini file. Without it your mod will not display.
;ModTitle : This is the title of the mod and will be displayed in the select list of the "User Mods" tab.
;ModLogo : This is the full name (ie: Package.texture) of the image to be displayed on the "User Mods" tab of the community menu when someone selects your mod. The texture should be 512x128.
;ModDesc : This options sets the description that will show in the box on the "User Mods"tab. You can use the pipe character "|" to add line breaks to the display.
;ModCmdLine : This is the command line that will be used to launch your mod. You do not need to include the "–mod=" as it will be auto-appended.
;ModURL : This is a hyperlink to a web site for your mod.

Template

<source lang=ini>

[Mod]

ModTitle=

ModLogo=

ModDesc=

ModCmdLine=

ModURL=
</source>

==Related Topics==
* [[Legacy:Set Up Package Folders|Set Up Package Folders]]
* [[Legacy:Game Ini File|Game Ini File]]
**[[Legacy:UT2004.Ini|UT2004.ini]]
***UT2k4Mod.ini
***[[UE2:UT2004 Default.ini|UT2004 Default.ini]] – Used for generating UT2004.ini's
***[[Legacy:UT2k4 DefaultUser.Ini|UT2k4 DefaultUser.ini]] – Used for generating User.ini's 

==External Links==
:*[[udn2:ImprovedModSupport|Improved Mod Support]]

File:Icon-UT2004.png

2008-05-05T12:01:59Z

Azrael:

[[Unreal Tournament 2004|UT2004]] icon for [[Template:Infobox class]] and [[Template:Infobox interface]].

Comments

2008-05-05T12:00:15Z

Azrael: Added some basic content.

'''Comments''' are a way of inserting text into [[UnrealScript]] code to remind yourself of what the code is doing, or to give a summary of the code file. Comments will be ignored by the compiler, so they can also be used to temporarily 'disable' a line of text.

Anything on a line after the special comment symbol '''//''' is a comment. For example, many official Unreal Tournament files have headers such as this:

<uscript>//=============================================================================
// A sticky note. Level designers can place these in the level and then
// view them as a batch in the error/warnings window.
//=============================================================================
class Note extends Actor
placeable
native;

#exec Texture Import File=Textures\Note.pcx Name=S_Note Mips=Off MASKED=1

var() string Text;
</uscript>

To disable a line of text, simple insert the // before it, like this:
<uscript>simulated function ShaderAction( Shader sh )
{
//log("ShaderAction " $ sh );

switch( MatTriggerAction )
{
case MTA_SwapShaderSpecular:
sh.Specular = SwapMaterialA;
break;
}

}</uscript>

Unreal Tournament

2008-05-05T11:53:38Z

Azrael: New page: {{stub}} '''Unreal Tournament''', also referred to as '''UT '99''', is the first game in the Unreal Tournament series. It used the same engine version as the original Unreal, and incl...

{{stub}}

'''Unreal Tournament''', also referred to as '''UT '99''', is the first game in the Unreal Tournament series. It used the same engine version as the original [[Unreal]], and included all the content from it apart from the levels.

Class

2008-05-05T11:41:43Z

Azrael: Redirecting to Legacy:Class Syntax

#REDIRECT [[Legacy:Class Syntax]]

Template talk:Navbox unrealscript

2008-05-05T11:39:14Z

Azrael: New page: