Unreal Wiki - User contributions [en]

Compiler directives

2017-08-17T11:30:51Z

Wormbo: Reverted edits by 216.156.220.117 (talk) to last revision by SeriousBarbie

'''Compiler directives''' are lines in [[UnrealScript]] source files that affect compiler behavior and have no meaning at runtime. They are not really used anymore in [[Unreal Engine 3]], which comes with a powerful [[preprocessor]] instead.

Directives are parsed during the compile process, not before that. This means they cannot be used in [[defaultproperties]] or [[cpptext]] sections. In fact, any directives in cpptext blocks will end up in exported header files for preprocessing by the C++ compiler.

==Syntax==
Compiler directives must be placed on a separate line. The syntax is as follows:
'''#'''''directivename'' ''parameters''
There must not be anything else before the '''#''' on that line and there shouldn't be anything after the directive name and parameters, except maybe a line comment. Directive names are case-insensitive, like any other part of UnrealScript syntax.

==Unreal Engine 1/2==
===call===
Similar to the "exec" console command in the editor and the game. Loads a list of console commands from a text file and executes them.

See [[exec commands]] for a useful selection of commands.

===error===
Immediately stops compiling with the message: "#Error directive encountered"

Note that there is no built-in conditional compiling, so using this directive may be quite pointless without an external preprocessor tool like [[UCPP]].

===exec===
The most-used directive and probably the only one most UnrealScript programmers ever need to use. The '''#exec''' directive executes an editor console command in the context of the compiler.

See [[exec commands]] for a useful selection of commands.

==Unreal Engine 2==

===include===
Loads a text file and replaces the #include line with its content.

There are several things to watch out for when using this directive:
* Line numbers reported in errors and warnings after the #include line will reflect the source text with the included content, so they no longer match the original source line numbers.
* If the included file contains a [[defaultproperties]] block, it is not included directly. Instead, its content is inserted into the class's defaultproperties block.

==Unreal Engine 3==
The only known directive in Unreal Engine 3 is '''#linenumber''', which is inserted by the preprocessor after an '''`include''' macro to make sure the compiler reports the line numbers the user expects.

{{navbox unrealscript}}

Talk:Unreal Unit

2017-07-10T17:38:28Z

Wormbo: moved comment/question from article page

It seems that the unreal unit directly corresponds to the centimeters in 3ds max. I jsut thought this might be helpful for anyone starting a project on UDK, not for UT3.

Isn't the UE2.X scale 50UU = 1m? It most certainly isn't 52.5. -Calypto

Unreal Unit

2017-07-10T17:37:46Z

Wormbo: Reverted edits by 24.59.51.157 (talk) to last revision by SeriousBarbie

An '''Unreal Unit''' ('''UU''' for short or just "units") is the basic unit of length in the [[Unreal Engine]]. Distances, brush dimensions and collision cylinder sizes are always measured in UU, velocities in UU per [[game second]] and so on. The grid in [[UnrealEd]] is is based on Unreal Units.

Angular units for [[rotator]] values are occasionally called "Unreal Units" as well, though this is a slightly different thing. Sometimes you also see the term "Unreal Rotation Unit" or "Rotational Unreal Unit" (URU/RUU) used instead.

==Relation to real-world units==
There is no fixed relation between Unreal Units and real-world units such as [[wp:meter|meter]] or [[wp:inch|inch]]. The actual scale depends on the game.

[[Unreal Engine]] games seem to be based on a scale where 16 UU roughly correspond to 1 [[wp:foot (length)|foot]], or 52.5 UU to 1 meter. The actual scale differs for the various games, though. You can get a rough idea about a specific game's scale by comparing the collision cylinder size of the player class to an average human's size. You will often notice that the horizontal and vertical scale don't quite match:
{|
! Game !! Player class !! Collision radius (x2) !! Collision height (x2)
|-
| [[Unreal]] || [[UE1:Human (U1)|Human]] || 34.0 UU || 78.0 UU
|-
| [[UT]] || [[UE1:TournamentPlayer (UT)|TournamentPlayer]] || 34.0 UU || 78.0 UU
|-
| [[Unreal 2]] || [[UE2:U2Pawn (U2)|U2Pawn]] || 56.0 UU || 116.0 UU
|-
| [[Unreal 2: XMP]] || [[UE2:U2Pawn (U2XMP)|U2Pawn]]{{confirm}} || 56.0 UU || 108.0 UU
|-
| [[UT2003]]/[[UT2004]] || [[UE2:XPawn (UT2004)|XPawn]] || 50.0 UU || 88.0 UU
|-
| [[UT3]] || [[UE3:UTPawn (UT3)|UTPawn]] || 42.0 UU || 88.0 UU
|}
The ''CollisionRadius'' and ''CollisionHeight'' values only represent half the collision cylinder dimensions, thus the table above lists values doubled.

Assuming a player height of about 5'9" or 1.75m, the following table of vertical scales can be calculated:

{|
! Game !! Scale (1 foot) !! Scale (1 meter)
|-
| [[Unreal]]/[[UT]] || 13.6 UU || 44.6 UU
|-
| [[Unreal 2]] || 20.2 UU || 66.3 UU
|-
| [[Unreal 2: XMP]] || 18.8 UU || 61.7 UU
|-
| [[UT2003]]/[[UT2004]]/[[UT3]] || 15.3 UU || 50.3 UU
|}
These values obviously differ from the 16UU=1ft scale mentioned above, with the newer UT games being closest to this scale. Keep in mind these are vertical scales and just as roughly estimated as any other scale in the [[Unreal Engine]]. Map dimensions should not be based on converted real-world scales, but instead on [[player movement metrics]].

== See Also ==
* [[Legacy:Movement Metrics (UT)]]

[[Category:Mapping articles]] [[Category:Programming articles]]

Talk:DamageType

2016-11-13T16:17:54Z

Wormbo:

Why are you people so keen on referencing legacy pages from the non-legacy part of the wiki? —[[User:Wormbo|Wormbo]] 00:23, 11 November 2016 (EST)
:Is there any definition available here what is classified as "legacy" and what as "non-legacy"? I didn't find such. I guess that everything related to current Unreal engine is "non-legacy", everything to previous versions "legacy". But that would be a bad classification IMO. --[[User:SeriousBarbie|SeriousBarbie]] ([[User talk:SeriousBarbie|talk]]) 10:08, 11 November 2016 (EST)
::It's right in the page name, the "Legacy" part before the colon. Background is that the old UnrealWiki (before the switch to MediaWiki) had a very wonky copyright statement. —[[User:Wormbo|Wormbo]] 11:25, 11 November 2016 (EST)
:::Oh, I thought it was an indicator for "out of date". I must say that I'm really confused about the structure and different copyrights here (it has taken more that two years or me to accidentally find [[Unreal Wiki:Copyrights]]...) Isn't it possible to get rid of these different copyrights? A note to the copyright holder: on [[Legacy:Project_Copyright]] I found the statement ''The collection and structure of UnrealWiki are copyright UnrealWiki''. But I did not find any information what ''UnrealWiki'' is - a foundation, person or company?
:::Back to concrete: Instead of editing "legacy" pages: what should I do if I want to add some infos on a matter that is classified as "legacy"? (Let's take [https://wiki.beyondunreal.com/Legacy:LevelInfo_%28UT%29?curid=1704&diff=46379&oldid=46169 this change] as an example.)
:::And if I create complete new content ("non-legacy"), why is it unwanted to link to "legacy" pages there? --[[User:SeriousBarbie|SeriousBarbie]] ([[User talk:SeriousBarbie|talk]]) 08:36, 13 November 2016 (EST)
::The reason is exactly your confusion about the old wiki's copyright. Technically it should have been something like CC-BY, but to change a copyright like the one the old wiki has, all contributors (everyone who ever contributed any edits to it that are still visible) would have to agree to such a change, which simply isn't possible. That's why the entire old wiki's content is now in its own Legacy namespace.
::If you want to add anything, it would be great if you could create an appropriate non-Legacy page (if it doesn't exist yet) and link it accordingly from inside the wiki and also from outside the wiki. In general, just have a look at [[Project:Community portal|Community portal]]. —[[User:Wormbo|Wormbo]] 11:17, 13 November 2016 (EST)

File:LegacyBackground.png

2016-11-11T16:43:45Z

Wormbo: Wormbo uploaded a new version of File:LegacyBackground.png

Background image for pages in the [[Project:Namespaces#Legacy|legacy namespace]].

Talk:DamageType

2016-11-11T16:25:04Z

Wormbo:

MediaWiki:Common.css

2016-11-11T05:42:34Z

Wormbo: testing more prominent legacy edit notice

/* <source lang="css">

Styles for page content that will be applied to all skins.
*/

/** Infobox layout *************************************************************
*
* Description: General style for infobox-like content objects.
*/
table.infobox, div.infobox {
background: #fed;
border: 1px solid #88a;
padding: 1em;
}
table.infobox {
float: right;
margin: 1em;
margin-right: 0;
width: 300px;
}
div.infobox {
margin: 1em 0;
padding: 0.5em;
}

table.infobox th {
text-align: left;
padding: 1px;
padding-right: 10px;
vertical-align: top;
}
table.infobox td {
width: 100%;
}
table.infobox.infobox-pages th {
text-align: center;
padding-right: 1px;
vertical-align: top;
}

/** Generic lists *************************************************************
*
* Description: top/left aligned table cells for list tables
*/
table.list th, table.list td {
text-align: left;
vertical-align: top;
}

.list.defaults {
background-color: #fff;
border: solid 1px #c0c0c0;
}
.list.defaults td {
background-color: #e0f0f7;
border: solid 1px #c0c0c0;
}

/** Navbox layout *************************************************************
*
* Description: General style for navigation boxes.
*/
table.navbox {
background: white;
border: 1px solid #88a;
border-spacing: 2px;
margin: 10px 0px 5px;
padding: 0px;
font-size: 88%;
width: 100%;
}
table.navbox th,
table.navbox td {
padding: 0.1em 0.5em;
}
table.navbox th.navbox-header {
background: #bdb;
}
table.navbox th.navbox-group {
background: #cfc;
text-align: right;
white-space: nowrap;
}
table.navbox td.navbox-body {
text-align: center;
width: 100%;
}
table.navbox tr.navbox-body.even {
background: #f0f0f0;
}

/** non-wrapped links **********************************************************
*
* Description: Prevents contained links from being broken up at end of line.
*/
.nowraplinks a {
white-space: nowrap;
}

/** Article message boxes ******************************************************
*
* Description: Various display styles for the ambox template.
*/
table.ambox {
margin: 0px 10%;
border-collapse: collapse;
background: white;
border: 1px solid #19f; /* default notice color */
border-left-width: 10px;
}
/* The message body cell(s) */
table.ambox th.ambox-text, table.ambox td.ambox-text {
padding: 0.25em 0.5em;
width: 100%;
}
/* The left image cell */
table.ambox td.ambox-image {
padding: 2px 0px 2px 0.5em;
text-align: center;
}
/* The right image cell */
table.ambox td.ambox-imageright {
padding: 2px 0.5em 2px 0px;
text-align: center;
}

/* type 'notice' (default) */
table.ambox-notice {
border-color: #19f;
}
/* type 'serious' */
table.ambox-serious {
border-color: #b22;
background: #fee;
}
/* type 'content' */
table.ambox-content {
border-color: #f80;
}
/* type 'style' */
table.ambox-style {
border-color: #fc0;
}
/* type 'info' */
table.ambox-info{
border-width: 1px;
border-color: #88a;
}

/** Template documentation *****************************************************
*
* Description: Display styles for template documentation.
*/
.template-documentation {
clear: both;
margin: 0px;
margin-top: 1em;
border: 1px solid #aaa;
background-color: #eee;
padding: 5px;
}

/** Disambiguation links *******************************************************
*
* Description: Display styles for disambiguation templates.
*/
.dablink {
font-style: italic;
padding-left: 2em;
}

.dablink i {
font-style: normal;
}

/** Interwiki links *************************************************************
*
* Description: Icons and colors for interwiki links.
*/
#bodyContent a.extiw:link {
color: #080;
}
#bodyContent a.extiw:visited {
color: #060;
}

#bodyContent a.extiw[title^="wp:"],
#bodyContent a.extiw[title^="wikipedia:"] {
padding-left: 10px !important;
background: url(/w/images/InterWiki-Wikipedia.png) no-repeat left center !important;
}
#bodyContent a.extiw[title^="liandri:"] {
padding-left: 10px !important;
background: url(/w/images/InterWiki-Liandri.png) no-repeat left center !important;
}
#bodyContent a.extiw[title^="uadmin:"] {
padding-left: 16px !important;
background: url(/w/images/InterWiki-UAWiki.png) no-repeat left center !important;
}
#bodyContent a.extiw[title^="udn2:"],
#bodyContent a.extiw[title^="udn3:"] {
padding-left: 18px !important;
background: url(/w/images/InterWiki-UDN.png) no-repeat left center !important;
}

/* links to legacy namespace */
#bodyContent a[title^="Legacy:"],
#bodyContent a[title^="Legacy talk:"],
#bodyContent a.CategoryTreeLabel[href^="/Category:Legacy"],
#bodyContent a[title^="Category:Legacy"],
#bodyContent a[title^="Category talk:Legacy"] {
padding-left: 21px !important;
background: url(/w/images/OldWikiIcon.png) no-repeat left center !important;
}

/* no icon in legacy and category namespaces */
body[class*="page-Category_Legacy_"] #bodyContent a[title^="Legacy:"],
body[class*="page-Category_Legacy_"] #bodyContent a[title^="Legacy talk:"],
body[class*="page-Category_Legacy_"] #bodyContent a.CategoryTreeLabel[href^="/Category:Legacy"],
body[class*="page-Category_Legacy_"] #bodyContent a[title^="Category:Legacy"],
body[class*="page-Category_Legacy_"] #bodyContent a[title^="Category talk:Legacy"],
body[class*="page-Category_talk_Legacy_"] #bodyContent a[title^="Legacy:"],
body[class*="page-Category_talk_Legacy_"] #bodyContent a[title^="Legacy talk:"],
body[class*="page-Category_talk_Legacy_"] #bodyContent a[title^="Category:Legacy"],
body[class*="page-Category_talk_Legacy_"] #bodyContent a[title^="Category talk:Legacy"],
.ns-100 #bodyContent a[title^="Legacy:"],
.ns-100 #bodyContent a[title^="Legacy talk:"],
.ns-100 #bodyContent a[title^="Category:Legacy"],
.ns-100 #bodyContent a[title^="Category talk:Legacy"],
.ns-101 #bodyContent a[title^="Legacy:"],
.ns-101 #bodyContent a[title^="Legacy talk:"],
.ns-101 #bodyContent a[title^="Category:Legacy"],
.ns-101 #bodyContent a[title^="Category talk:Legacy"] {
padding-left: 0px !important;
background: transparent !important;
}

/** Quote style *****************************************************************
*
* Description: Display style for quote template.
*/
blockquote.quote-text {
background: #def;
border: 1px solid #aaa;
margin: 1em 10%;
padding: 0 0.5em;
}

blockquote.quote-text .quote-source {
text-align: right;
font-size: 88%;
font-style: italic;
margin-bottom: 0.5em;
}

/** Legacy warning **************************************************************
*
* Description: Display style for warning shown when editing legacy pages.
*/
#mw-legacypageedit {
background-color: white;
border: 1px solid #f80;
border-left-width: 10px;
margin: 0.5em 10%;
padding: 0.2em 0.4em;
font-size: 200%;
line-height: 120%;
}

/** prevent ugly horizontal page expansion *************************************/
pre { overflow: auto; }

/** improved diff highlighting *************************************************/
ins.diffchange { background-color: #CD8; }
del.diffchange { background-color: #FDA; }

/* </source> */

MediaWiki:Common.css

2016-11-11T05:41:46Z

Wormbo: testing more prominent legacy edit notice

/* <source lang="css">

Styles for page content that will be applied to all skins.
*/

/** Infobox layout *************************************************************
*
* Description: General style for infobox-like content objects.
*/
table.infobox, div.infobox {
background: #fed;
border: 1px solid #88a;
padding: 1em;
}
table.infobox {
float: right;
margin: 1em;
margin-right: 0;
width: 300px;
}
div.infobox {
margin: 1em 0;
padding: 0.5em;
}

table.infobox th {
text-align: left;
padding: 1px;
padding-right: 10px;
vertical-align: top;
}
table.infobox td {
width: 100%;
}
table.infobox.infobox-pages th {
text-align: center;
padding-right: 1px;
vertical-align: top;
}

/** Generic lists *************************************************************
*
* Description: top/left aligned table cells for list tables
*/
table.list th, table.list td {
text-align: left;
vertical-align: top;
}

.list.defaults {
background-color: #fff;
border: solid 1px #c0c0c0;
}
.list.defaults td {
background-color: #e0f0f7;
border: solid 1px #c0c0c0;
}

/** Navbox layout *************************************************************
*
* Description: General style for navigation boxes.
*/
table.navbox {
background: white;
border: 1px solid #88a;
border-spacing: 2px;
margin: 10px 0px 5px;
padding: 0px;
font-size: 88%;
width: 100%;
}
table.navbox th,
table.navbox td {
padding: 0.1em 0.5em;
}
table.navbox th.navbox-header {
background: #bdb;
}
table.navbox th.navbox-group {
background: #cfc;
text-align: right;
white-space: nowrap;
}
table.navbox td.navbox-body {
text-align: center;
width: 100%;
}
table.navbox tr.navbox-body.even {
background: #f0f0f0;
}

/** non-wrapped links **********************************************************
*
* Description: Prevents contained links from being broken up at end of line.
*/
.nowraplinks a {
white-space: nowrap;
}

/** Article message boxes ******************************************************
*
* Description: Various display styles for the ambox template.
*/
table.ambox {
margin: 0px 10%;
border-collapse: collapse;
background: white;
border: 1px solid #19f; /* default notice color */
border-left-width: 10px;
}
/* The message body cell(s) */
table.ambox th.ambox-text, table.ambox td.ambox-text {
padding: 0.25em 0.5em;
width: 100%;
}
/* The left image cell */
table.ambox td.ambox-image {
padding: 2px 0px 2px 0.5em;
text-align: center;
}
/* The right image cell */
table.ambox td.ambox-imageright {
padding: 2px 0.5em 2px 0px;
text-align: center;
}

/* type 'notice' (default) */
table.ambox-notice {
border-color: #19f;
}
/* type 'serious' */
table.ambox-serious {
border-color: #b22;
background: #fee;
}
/* type 'content' */
table.ambox-content {
border-color: #f80;
}
/* type 'style' */
table.ambox-style {
border-color: #fc0;
}
/* type 'info' */
table.ambox-info{
border-width: 1px;
border-color: #88a;
}

/** Template documentation *****************************************************
*
* Description: Display styles for template documentation.
*/
.template-documentation {
clear: both;
margin: 0px;
margin-top: 1em;
border: 1px solid #aaa;
background-color: #eee;
padding: 5px;
}

/** Disambiguation links *******************************************************
*
* Description: Display styles for disambiguation templates.
*/
.dablink {
font-style: italic;
padding-left: 2em;
}

.dablink i {
font-style: normal;
}

/** Interwiki links *************************************************************
*
* Description: Icons and colors for interwiki links.
*/
#bodyContent a.extiw:link {
color: #080;
}
#bodyContent a.extiw:visited {
color: #060;
}

#bodyContent a.extiw[title^="wp:"],
#bodyContent a.extiw[title^="wikipedia:"] {
padding-left: 10px !important;
background: url(/w/images/InterWiki-Wikipedia.png) no-repeat left center !important;
}
#bodyContent a.extiw[title^="liandri:"] {
padding-left: 10px !important;
background: url(/w/images/InterWiki-Liandri.png) no-repeat left center !important;
}
#bodyContent a.extiw[title^="uadmin:"] {
padding-left: 16px !important;
background: url(/w/images/InterWiki-UAWiki.png) no-repeat left center !important;
}
#bodyContent a.extiw[title^="udn2:"],
#bodyContent a.extiw[title^="udn3:"] {
padding-left: 18px !important;
background: url(/w/images/InterWiki-UDN.png) no-repeat left center !important;
}

/* links to legacy namespace */
#bodyContent a[title^="Legacy:"],
#bodyContent a[title^="Legacy talk:"],
#bodyContent a.CategoryTreeLabel[href^="/Category:Legacy"],
#bodyContent a[title^="Category:Legacy"],
#bodyContent a[title^="Category talk:Legacy"] {
padding-left: 21px !important;
background: url(/w/images/OldWikiIcon.png) no-repeat left center !important;
}

/* no icon in legacy and category namespaces */
body[class*="page-Category_Legacy_"] #bodyContent a[title^="Legacy:"],
body[class*="page-Category_Legacy_"] #bodyContent a[title^="Legacy talk:"],
body[class*="page-Category_Legacy_"] #bodyContent a.CategoryTreeLabel[href^="/Category:Legacy"],
body[class*="page-Category_Legacy_"] #bodyContent a[title^="Category:Legacy"],
body[class*="page-Category_Legacy_"] #bodyContent a[title^="Category talk:Legacy"],
body[class*="page-Category_talk_Legacy_"] #bodyContent a[title^="Legacy:"],
body[class*="page-Category_talk_Legacy_"] #bodyContent a[title^="Legacy talk:"],
body[class*="page-Category_talk_Legacy_"] #bodyContent a[title^="Category:Legacy"],
body[class*="page-Category_talk_Legacy_"] #bodyContent a[title^="Category talk:Legacy"],
.ns-100 #bodyContent a[title^="Legacy:"],
.ns-100 #bodyContent a[title^="Legacy talk:"],
.ns-100 #bodyContent a[title^="Category:Legacy"],
.ns-100 #bodyContent a[title^="Category talk:Legacy"],
.ns-101 #bodyContent a[title^="Legacy:"],
.ns-101 #bodyContent a[title^="Legacy talk:"],
.ns-101 #bodyContent a[title^="Category:Legacy"],
.ns-101 #bodyContent a[title^="Category talk:Legacy"] {
padding-left: 0px !important;
background: transparent !important;
}

/** Quote style *****************************************************************
*
* Description: Display style for quote template.
*/
blockquote.quote-text {
background: #def;
border: 1px solid #aaa;
margin: 1em 10%;
padding: 0 0.5em;
}

blockquote.quote-text .quote-source {
text-align: right;
font-size: 88%;
font-style: italic;
margin-bottom: 0.5em;
}

/** Legacy warning **************************************************************
*
* Description: Display style for warning shown when editing legacy pages.
*/
#mw-legacypageedit {
background-color: white;
border: 1px solid #f80;
border-left-width: 10px;
margin: 0.5em 10%;
padding: 0.2em 0.4em;
font-size: 200%;
}

/** prevent ugly horizontal page expansion *************************************/
pre { overflow: auto; }

/** improved diff highlighting *************************************************/
ins.diffchange { background-color: #CD8; }
del.diffchange { background-color: #FDA; }

/* </source> */

MediaWiki:Common.css

2016-11-11T05:39:09Z

Wormbo: testing more prominent legacy edit notice

/* <source lang="css">

Styles for page content that will be applied to all skins.
*/

/** Infobox layout *************************************************************
*
* Description: General style for infobox-like content objects.
*/
table.infobox, div.infobox {
background: #fed;
border: 1px solid #88a;
padding: 1em;
}
table.infobox {
float: right;
margin: 1em;
margin-right: 0;
width: 300px;
}
div.infobox {
margin: 1em 0;
padding: 0.5em;
}

table.infobox th {
text-align: left;
padding: 1px;
padding-right: 10px;
vertical-align: top;
}
table.infobox td {
width: 100%;
}
table.infobox.infobox-pages th {
text-align: center;
padding-right: 1px;
vertical-align: top;
}

/** Generic lists *************************************************************
*
* Description: top/left aligned table cells for list tables
*/
table.list th, table.list td {
text-align: left;
vertical-align: top;
}

.list.defaults {
background-color: #fff;
border: solid 1px #c0c0c0;
}
.list.defaults td {
background-color: #e0f0f7;
border: solid 1px #c0c0c0;
}

/** Navbox layout *************************************************************
*
* Description: General style for navigation boxes.
*/
table.navbox {
background: white;
border: 1px solid #88a;
border-spacing: 2px;
margin: 10px 0px 5px;
padding: 0px;
font-size: 88%;
width: 100%;
}
table.navbox th,
table.navbox td {
padding: 0.1em 0.5em;
}
table.navbox th.navbox-header {
background: #bdb;
}
table.navbox th.navbox-group {
background: #cfc;
text-align: right;
white-space: nowrap;
}
table.navbox td.navbox-body {
text-align: center;
width: 100%;
}
table.navbox tr.navbox-body.even {
background: #f0f0f0;
}

/** non-wrapped links **********************************************************
*
* Description: Prevents contained links from being broken up at end of line.
*/
.nowraplinks a {
white-space: nowrap;
}

/** Article message boxes ******************************************************
*
* Description: Various display styles for the ambox template.
*/
table.ambox {
margin: 0px 10%;
border-collapse: collapse;
background: white;
border: 1px solid #19f; /* default notice color */
border-left-width: 10px;
}
/* The message body cell(s) */
table.ambox th.ambox-text, table.ambox td.ambox-text {
padding: 0.25em 0.5em;
width: 100%;
}
/* The left image cell */
table.ambox td.ambox-image {
padding: 2px 0px 2px 0.5em;
text-align: center;
}
/* The right image cell */
table.ambox td.ambox-imageright {
padding: 2px 0.5em 2px 0px;
text-align: center;
}

/* type 'notice' (default) */
table.ambox-notice {
border-color: #19f;
}
/* type 'serious' */
table.ambox-serious {
border-color: #b22;
background: #fee;
}
/* type 'content' */
table.ambox-content {
border-color: #f80;
}
/* type 'style' */
table.ambox-style {
border-color: #fc0;
}
/* type 'info' */
table.ambox-info{
border-width: 1px;
border-color: #88a;
}

/** Template documentation *****************************************************
*
* Description: Display styles for template documentation.
*/
.template-documentation {
clear: both;
margin: 0px;
margin-top: 1em;
border: 1px solid #aaa;
background-color: #eee;
padding: 5px;
}

/** Disambiguation links *******************************************************
*
* Description: Display styles for disambiguation templates.
*/
.dablink {
font-style: italic;
padding-left: 2em;
}

.dablink i {
font-style: normal;
}

/** Interwiki links *************************************************************
*
* Description: Icons and colors for interwiki links.
*/
#bodyContent a.extiw:link {
color: #080;
}
#bodyContent a.extiw:visited {
color: #060;
}

#bodyContent a.extiw[title^="wp:"],
#bodyContent a.extiw[title^="wikipedia:"] {
padding-left: 10px !important;
background: url(/w/images/InterWiki-Wikipedia.png) no-repeat left center !important;
}
#bodyContent a.extiw[title^="liandri:"] {
padding-left: 10px !important;
background: url(/w/images/InterWiki-Liandri.png) no-repeat left center !important;
}
#bodyContent a.extiw[title^="uadmin:"] {
padding-left: 16px !important;
background: url(/w/images/InterWiki-UAWiki.png) no-repeat left center !important;
}
#bodyContent a.extiw[title^="udn2:"],
#bodyContent a.extiw[title^="udn3:"] {
padding-left: 18px !important;
background: url(/w/images/InterWiki-UDN.png) no-repeat left center !important;
}

/* links to legacy namespace */
#bodyContent a[title^="Legacy:"],
#bodyContent a[title^="Legacy talk:"],
#bodyContent a.CategoryTreeLabel[href^="/Category:Legacy"],
#bodyContent a[title^="Category:Legacy"],
#bodyContent a[title^="Category talk:Legacy"] {
padding-left: 21px !important;
background: url(/w/images/OldWikiIcon.png) no-repeat left center !important;
}

/* no icon in legacy and category namespaces */
body[class*="page-Category_Legacy_"] #bodyContent a[title^="Legacy:"],
body[class*="page-Category_Legacy_"] #bodyContent a[title^="Legacy talk:"],
body[class*="page-Category_Legacy_"] #bodyContent a.CategoryTreeLabel[href^="/Category:Legacy"],
body[class*="page-Category_Legacy_"] #bodyContent a[title^="Category:Legacy"],
body[class*="page-Category_Legacy_"] #bodyContent a[title^="Category talk:Legacy"],
body[class*="page-Category_talk_Legacy_"] #bodyContent a[title^="Legacy:"],
body[class*="page-Category_talk_Legacy_"] #bodyContent a[title^="Legacy talk:"],
body[class*="page-Category_talk_Legacy_"] #bodyContent a[title^="Category:Legacy"],
body[class*="page-Category_talk_Legacy_"] #bodyContent a[title^="Category talk:Legacy"],
.ns-100 #bodyContent a[title^="Legacy:"],
.ns-100 #bodyContent a[title^="Legacy talk:"],
.ns-100 #bodyContent a[title^="Category:Legacy"],
.ns-100 #bodyContent a[title^="Category talk:Legacy"],
.ns-101 #bodyContent a[title^="Legacy:"],
.ns-101 #bodyContent a[title^="Legacy talk:"],
.ns-101 #bodyContent a[title^="Category:Legacy"],
.ns-101 #bodyContent a[title^="Category talk:Legacy"] {
padding-left: 0px !important;
background: transparent !important;
}

/** Quote style *****************************************************************
*
* Description: Display style for quote template.
*/
blockquote.quote-text {
background: #def;
border: 1px solid #aaa;
margin: 1em 10%;
padding: 0 0.5em;
}

blockquote.quote-text .quote-source {
text-align: right;
font-size: 88%;
font-style: italic;
margin-bottom: 0.5em;
}

/** Legacy warning **************************************************************
*
* Description: Display style for warning shown when editing legacy pages.
*/
#mw-legacypageedit {
background-color: white;
border: 1px solid #f80;
border-left-width: 10px;
margin: 0.5em 10%;
padding: 0.2em 0.4em;
font-size: 200%;
}

#mw-legacypageedit::before {
content: "Important: ";
}

/** prevent ugly horizontal page expansion *************************************/
pre { overflow: auto; }

/** improved diff highlighting *************************************************/
ins.diffchange { background-color: #CD8; }
del.diffchange { background-color: #FDA; }

/* </source> */

Legacy:FlockPawn

2016-11-11T05:28:11Z

Wormbo: linking from Legacy to non-Legacy pages is discouraged. yes, that particular thing is meant to be complicated.

{{classbox| [[Legacy:UT|UT]] :: [[Legacy:Actor (UT)|Actor (UT)]] >> [[Legacy:Pawn (UT)|Pawn (UT)]] >> FlockPawn}}

These are quite easy, so i dont know why no-one did them before:

The flockpawns are:
*Bird1
*BiterFish
*Bloblet
*Horsefly
*NaliRabbit

All of these (except the rabbit and the bird) need a [[Legacy:FlockMasterPawn|FlockMasterPawn]] to work.

Heres how to use them all:

===The Amoeba (Bloblet)===

This is the most complicated flockpawn, and has only ever been used properly once (I think).

To work it, place several Bloblet actors in one area, then place the ParentBlob pawn (the controller of the bloblets) in the middle of the group. Open the properties of all the bloblets and the parentblob and change them to the same tag; add several triggers around your map and set the event to the amoeba's tag (to keep it constantly aggressive) and there you have a working amoeba!

Notes:
* I don't know if this works online, but it does offline.
* Bloblets are immune against [[Legacy:DamageType (UT)|DamageType]] ''corroded''.

===Biter Fish===

These are easier than bloblets, you just simply put the [[Legacy:FlockMasterPawn|FlockMasterPawn]] in the level, then change the properties to control the number of fish, the fact that they are violent, and how far the fish swim from the master pawn. Horseflies work in the same way

===Birds and Nali Rabbits===

These are the easiest to work. Just place them in the level and watch them go! no master pawn needed

'''Ghost:''' With regards to the FlockMasterPawn Bird1, is it possible to export the Bird1 animation along with it's script sequence from UT over to UT2003?

'''Wormbo:''' You might be able to export it with the [[Legacy:WOTgreal|WOTgreal]] exporter or with the [[Legacy:UT Package Tool|UT Package Tool]]. To import it just use the [[Legacy:Exec Directive|exec directive]]s of the Bird1 class.

'''Ghost:''' That worked, thanks.

==Related Topics ==
* [[Legacy:Artificial Intelligence|Artificial Intelligence]]

[[Category:Legacy Class (UT)|{{PAGENAME}}]]

Talk:DamageType

2016-11-11T05:23:06Z

Wormbo: Created page with "Why are you people so keen on referencing legacy pages from the non-legacy part of the wiki? ~~~~"

Why are you people so keen on referencing legacy pages from the non-legacy part of the wiki? —[[User:Wormbo|Wormbo]] 00:23, 11 November 2016 (EST)

Legacy talk:Chain Of Events When Spawning Actors

2016-06-23T11:10:25Z

Wormbo: /* AlwaysRelevant() in UT? */ it's AlwaysKeep()

== AlwaysRelevant() in UT? ==
See this section:
<nowiki>...in UT

IsRelevant() first calls the base mutator's AlwaysRelevant() function</nowiki>
I may be wrong, but there is no AlwaysRelevant() function in UT, only bool variable bAlwaysRelevant.
(PS: the nowiki tag does not work) --[[User:SeriousBarbie|SeriousBarbie]] ([[User talk:SeriousBarbie|talk]]) 23:19, 21 June 2016 (EDT)

:The function is called AlwaysKeep() in all generations of UT. —[[User:Wormbo|Wormbo]] 07:10, 23 June 2016 (EDT)

Trace

2016-03-15T20:13:37Z

Wormbo: Created page with "A '''trace''' is a line check against relevant collision primitives of actors in the level. {{stub}} Category:Programming articles ==Tracing functions== The engine provid..."

A '''trace''' is a line check against relevant collision primitives of actors in the level.
{{stub}}
[[Category:Programming articles]]

==Tracing functions==
The engine provides multiple ways to perform line checks. Additionally it perfoms line checks internally when moving actors.

===Trace===
The most obvious choice. The '''Trace''' function performs a line check from a start location to an end location and returns the actor hit closest to the start location. Internally it still needs to find all hits and sort them by distance from the start to find the first hit.

You can pick whether you want to trace for only world geometry (BSP, movers, anything marked as <tt>bWorldGeometry</tt>) or all actors a projectile could hit (world geometry and any colliding actors that have <tt>bProjTarget</tt> or <tt>bBlockActors</tt>). Certain special cases, like tracing WaterVolumes or limiting trace results to only Pawns, can be enabled via actor properties. You likely won't find regular pickups using the '''Trace''' function, because they are not projectile targets. (Unless, for example, you are playing with "Volatile Ammo".)

===FastTrace===
This function checks only against BSP, Movers and <tt>bWorldGeometry</tt>. It only returns whether there was a hit or not, but does not provide any information about the hit whatsoever. As the name suggests, this is likely the fastest way to perform a trace, but you are limited in the tracing targets.

===TraceActors===
Performs a trace and then lets you iterate over the hits. Like '''Trace''', it will sort the hits by their distance from the start location.

'''TraceActors''' considers all colliding actors, even if they are not projectile targets, but of course it only returns hits that pass the class filter you specified. This is probably the most complete trace function you will find.

===TraceThisActor/TraceThisComponent===
Performs a trace only against the collision primitive of the actor or component it was called on, regardless of that actor's collision settings. You can use this function when you already know what you are likely going to hit, but want to figure out exactly how the hit will connect. This function is even faster than '''FastTrace''', but obviously has different applications than that.

==Alternative ways of tracing==
If the above functions do not satisfy your needs, there are also other ways to probe for collisions along a certain path.

If everything else fails, you can always spawn an actor with the collision settings you need an move it along the path you want to trace. You can use its Touch or HitWall events to collect any hits it encounters. To move it along a particular path, you can set up its Velocity and/or Acceleration and then call the '''AutonomousPhysics''' function to have the actor perform its configured physics as if the specified amount of game time passed. Alternatively you can use the '''Move''' function to specify a location offset to move the actor along, but Touch/Untouch notification may not be useful other than signaling that there was a collision.

PSA file

2016-03-13T18:57:32Z

Wormbo: Redirected page to PSK & PSA file formats

#REDIRECT [[PSK & PSA file formats]]

PSK file

2016-03-13T18:57:17Z

Wormbo: Redirected page to PSK & PSA file formats

#REDIRECT [[PSK & PSA file formats]]

PSK & PSA file formats

2016-03-13T18:56:47Z

Wormbo: Created page with "A '''PSK file''' stores shape and bone tree data for a skeletal mesh. A '''PSA file''' stores animation data for a particular skeletal bone tree. The two file types share a si..."

A '''PSK file''' stores shape and bone tree data for a skeletal mesh. A '''PSA file''' stores animation data for a particular skeletal bone tree. The two file types share a similar format and purpose, which is why they are described in the same article.

[[Category:File formats]]

==Shared binary format==
Generally PSK and PSA files consist of a number of binary chunks with a common header. The first chunk is empty and serves as the file header.

===Chunk layout===
{| class="wikitable"
|+ General chunk layout, offsets and lengths in decimal numbers
! Byte Offset !! Byte Length !! Type !! Description
|-
| 0 || 20 || Char[20] || Chunk ID.
|-
| 20 || 4 || Int || Type flags. If this value is decimal 1999801 or smaller, you are seeing the version of PSK/PSA files described here.
|-
| 24 || 4 || Int || Data size - how long each of the following data records are.
|-
| 28 || 4 || Int || Data count - how many data records will follow this header.
|-
| 32 || data size || binary || First data record in the chunk.
|-
| 32 + data size || data size || binary || Second data record in the chunk.
|-
| colspan="4" | ...
|-
| 32 + (data count - 1) * data size || data size || binary || Last data record in the chunk.
|}

A chunk may be empty, which is indicated by a data count of zero. In that case, data size may be zero as well. This is particularly true for the file header chunk.

===PSK file layout===
A PSK file specifies the skeletal mesh in its reference pose. PSK files seem to always consist of the following types of chunks in the specified order:

; File header : Chunk ID is "ACTRHEAD", type flags value is decimal 1999801 or lower for the file version described in this article. Data size and data count are zero, denoting an empty chunk body.
; Points : Lists the vertex points the mesh consists of. Data set type is [[#Point|Point]].
; Wedges : Lists the wedges, which basically assign a material UV coordinate to a particular mesh point. Data set type is [[#Vertex|Vertex]].
; Faces : List of triangle faces, combining three wedges to a triangle. Data set type is [[#Triangle|Triangle]].
; Materials : List of materials used by the mesh. Data set type is [[#Material|Material]].
; Reference bones : List of skeletal bones, their reference position and how the skeletal bone tree looks. Data set type is [[#Bone|Bone]].
; Influences : Defines how points are affected when bones move. Data set type is [[#RawBoneInfluence|RawBoneInfluence]].

===PSA file layout===
A PSA file specifies animation data for a skeletal bone tree. PSA files seem to always consist of the following types of chunks in the specified order:

; File header : Chunk ID is "ANIMHEAD", type flags value is decimal 1999801 or lower for the file version described in this article. Data size and data count are zero, denoting an empty chunk body.
; Bone names : List of skeletal bones, their reference position and how the skeletal bone tree looks. Data set type is [[#Bone|Bone]]. (Same as for PSK files.)
; Animation infos : Specifies the animations contained in this file, including name, group, length and affected bones. Data set type is [[#AnimInfo|AnimInfo]].
; Animation keys : Specifies the position, orientation and time index for a single bone. Data set type is [[#QuatAnimKey|QuatAnimKey]].

==Individual data structures==
This section lists the data structures involved in the file format. Generally, all multi-byte basic types are considered to be in little endian byte order.

===Byte===
An 8 bit unsigned integer value corresponding to the UnrealScript type [[byte]].

===Short===
A 16 bit integer value, usually assumed to be unsigned.

===Int===
A 32 bit integer value corresponding to the UnrealScript type [[int]], but usually assumed to be unsigned.

===Float===
A 32 bit floating point value corresponding to the UnrealScript type [[float]] or generally a [[wp:single-precision floating-point format|single-precision floating-point number]].

===Char[n]===
A series of exactly ''n'' bytes that are interpreted as a zero-terminated ASCII string filled with additional zero bytes to the required length.

===Vector===
An Euclidian vector denoting a position in 3D space, corresponding to the UnrealScript struct type [[Vector]]. Length: 12 bytes.

{| class="wikitable"
! Byte Offset !! Byte Length !! Type !! Name
|-
| 0 || 4 || Float || X
|-
| 4 || 4 || Float || Y
|-
| 8 || 4 || Float || Z
|}

===Quat===
A unit [[quaternion]] denoting an orientation or rotation in 3D space, corresponding to the UnrealScript struct type [[Quat]]. Length: 16 bytes.

{| class="wikitable"
! Byte Offset !! Byte Length !! Type !! Name
|-
| 0 || 4 || Float || X
|-
| 4 || 4 || Float || Y
|-
| 8 || 4 || Float || Z
|-
| 12 || 4 || Float || W
|}

===ChunkHeader===
The chunk header structure. Length: 32 bytes.

{| class="wikitable"
! Byte Offset !! Byte Length !! Type !! Name !! Description
|-
| 0 || 20 || Char[20] || ChunkID || The chunk name. The Unreal Engine does not really care about this value.
|-
| 20 || 4 || Int || TypeFlags || The Unreal Engine does not really care about this value either, even though it supposedly specifies a file version identifier.
|-
| 24 || 4 || Int || DataSize || The size of each data record potentially following this header.
|-
| 28 || 4 || Int || DataCount || The number of data records following this header.
|}

===Point===
Specifies a skeletal mesh vertex point. Length: 12 bytes.

{| class="wikitable"
! Byte Offset !! Byte Length !! Type !! Name !! Description
|-
| 0 || 12 || Vector || Point || The location of the point in the skeletal mesh's reference pose.
|}

===Vertex===
Associates skeletal mesh points with a UV coordinate of a material. Length: 12 bytes.

{| class="wikitable"
! Byte Offset !! Byte Length !! Type !! Name !! Description
|-
| 0 || 2 || Short || PointIndex || Index of the point in the points list.
|-
| 2 || 4 || Float || U || U coordinate in the material.
|-
| 6 || 4 || Float || V || V coordinate in the material.
|-
| 10 || 1 || Byte || MatIndex || Index of the material in the materials list. (seems unused, probably overridden by face's own MatIndex)
|-
| 11 || 1 || Byte || Reserved || Padding byte to get to a multiple of four bytes for the structure.
|}

===Triangle===
Combined three vertices to a triangle face. Length: 12 bytes.

{| class="wikitable"
! Byte Offset !! Byte Length !! Type !! Name !! Description
|-
| 0 || 3x 2 || 3x Short || WedgeIndex || Indices of the three vertices in the wedges list.
|-
| 6 || 1 || Byte || Matindex || Index of the face's material in the materials list.
|-
| 7 || 1 || Byte || AuxMatIndex || Index of an additional material in the materials list.
|-
| 8 || 4 || Int || SmoothingGroups || Bit field of smoothing groups this face belongs to.
|}

===Triangle===
Combined three vertices to a triangle face. Length: 12 bytes.

{| class="wikitable"
! Byte Offset !! Byte Length !! Type !! Name !! Description
|-
| 0 || 3x 2 || 3x Short || WedgeIndex || Indices of the three vertices in the wedges list.
|-
| 6 || 1 || Byte || MatIndex || Index of the face's material in the materials list.
|-
| 7 || 1 || Byte || AuxMatIndex || Index of an additional material in the materials list. (seems unused)
|-
| 8 || 4 || Int || SmoothingGroups || Bit field of smoothing groups this face belongs to. (Does the engine actually care about this for skeletal meshes?)
|}

===Material===
Specifies a surface material. Length: 88 bytes.

{| class="wikitable"
! Byte Offset !! Byte Length !! Type !! Name !! Description
|-
| 0 || 64 || Char[64] || MaterialName || Name of the material. The Unreal Engine will use this to find a texture or other material with this name in any package.
|-
| 64 || 4 || Int || TextureIndex || Should be the same as this material's index in the materials list. (But it's probably a good idea to not rely on the value being correct.)
|-
| 68 || 4 || Int || PolyFlags || Poly flags for all faces with this material. (seems unused)
|-
| 72 || 4 || Int || AuxMaterial || ??? (seems unused)
|-
| 76 || 4 || Int || AuxFlags || ??? (seems unused)
|-
| 80 || 4 || Int || LodBias || ??? (seems unused)
|-
| 84 || 4 || Int || LodStyle || ??? (seems unused)
|}

===JointPos===
A helper struct for storing the bone position. Length: 44 bytes.

{| class="wikitable"
! Byte Offset !! Byte Length !! Type !! Name !! Description
|-
| 0 || 16 || Quat || Orientation || Rotation of the bone, relative to its parent.
|-
| 16 || 12 || Vector || Position || Location of the bone, relative to its parent.
|-
| 28 || 4 || Float || Length || ??? (seems unused)
|-
| 32 || 4 || Float || XSize || ??? (seems unused)
|-
| 36 || 4 || Float || YSize || ??? (seems unused)
|-
| 40 || 4 || Float || ZSize || ??? (seems unused)
|}

===Bone===
Specifies a node in the skeletal bone tree for both the skeletal mesh and its animations. Length: 120 bytes.

{| class="wikitable"
! Byte Offset !! Byte Length !! Type !! Name !! Description
|-
| 0 || 64 || Char[64] || Name || Name of the bone.
|-
| 64 || 4 || Int || Flags || ??? (seems unused)
|-
| 68 || 4 || Int || NumChildren || Number of child nodes in the skeletal bone tree.
|-
| 72 || 4 || Int || ParentIndex || Index of this bone's parent in the bone list. The root bone must be the first in the bone list and have ParentIndex zero.
|-
| 76 || 4 || [[#JointPos|JointPos]] || BonePos || Bone position information.
|}

===RawBoneInfluence===
Specifies the influence of a bone's movement (through animation or otherwise) on a skeletal mesh point's position. Length: 12 bytes.

{| class="wikitable"
! Byte Offset !! Byte Length !! Type !! Name !! Description
|-
| 0 || 4 || Float || Weight || How strongly the bone's movement affects the point's location. Values are in the range (0.0; 1.0], i.e. zero weights should not appear in the influences list, because they are meaningless.
|-
| 4 || 4 || Int || PointIndex || Index of the affected point in the points list.
|-
| 8 || 4 || Int || BoneIndex || Index of the affecting bone in the bones list.
|}

===AnimInfo===
Specifies an animation sequence. Length: 168 bytes.

{| class="wikitable"
! Byte Offset !! Byte Length !! Type !! Name !! Description
|-
| 0 || 64 || Char[64] || Name || Name of the animation sequence.
|-
| 64 || 64 || Char[64] || Group || Group name for the animation sequence. While an animation sequence can be part of multiple groups in the Unreal Engine, the PSA format allows only a single group name to be specified here. You can use the AnimIsInGroup() UnrealScript function in Unreal Engine 2 to check if the currently playing animation in a specified channel is part of a particular animation group. You can use the GetAnimGroup() UnrealScript function in Unreal Engine 1 to get the group name of the currently playing animation.
|-
| 128 || 4 || Int || TotalBones || Total number of bones involved in this animation.
|-
| 132 || 4 || Int || RootInclude || ??? (seems unused)
|-
| 136 || 4 || Int || KeyCompressionStyle || ??? (related to animation compression)
|-
| 140 || 4 || Int || KeyQuotum || ??? (related to animation compression)
|-
| 144 || 4 || Float || KeyReduction || ??? (related to animation compression)
|-
| 148 || 4 || Float || TrackTime || ??? (seems unused as it's overridden by AnimRate * NumRawFrames)
|-
| 152 || 4 || Float || AnimRate || Default animation speed in frames per second.
|-
| 156 || 4 || Int || StartBone || ??? (something about partial animations, seems unused)
|-
| 160 || 4 || Int || FirstRawFrame || First entry in the animation keys list for this animation.
|-
| 164 || 4 || Int || NumRawFrames || Number of entries in the animation keys list for this animation.
|}

===QuatAnimKey===
Specifies the position, orientation and time index for a single bone in an animation sequence. Length: 32 bytes.

{| class="wikitable"
! Byte Offset !! Byte Length !! Type !! Name !! Description
|-
| 0 || 12 || Vector || Position || Position of the bone at this time index, relative to the parent bone.
|-
| 12 || 16 || Quat || Orientation || Orientation of the bone at this time index, relative to the parent bone.
|-
| 28 || 4 || Float || Time || The duration until the next key.
|}

==External links==
* [[udn2:BinaryFormatSpecifications|Binary format specifications for skeletal and vertex animation source files]]

Quaternion

2016-03-12T19:19:41Z

Wormbo: /* Definition */ Added subheadings to visually break up the section for easier reading, added a few details

[[wp:Quaternions|Quaternions]] are a mathematical construct that could be seen as an extension of the [[wp:complex numbers|complex numbers]] with three different imaginary units or as a combination of a scalar value and a three-dimensional [[vector]]. A special subset of the quaternions, the unit quaternions, can be used to represent rotations in 3D space.

[[Category:Programming articles]]

==Definition==
Generally a quaternion is a four-dimensional value that is written as either x = x0+ x1'''i''' + x2'''j''' + x3'''k''' or as x = (x0, x1, x2, x3), where x0 is called the real or scalar part Re(x) and (x1, x2, x3) is the imaginary or vector part Im(x). If the vector part is zero, the quaternion is called real, while a quaternion with a zero scalar part is called a pure imaginary quaternion. Real quaternions (x0, 0, 0, 0) could also be written as x0+ 0'''i''' + 0'''j''' + 0'''k''' = x0.

===Additive operations===
Addition, subtraction and negation of quaternions is defined the same way as for vectors:
* x + y = y + x = (x0+ y0, x1+ y1, x2+ y2, x3+ y3)
* x - y = -y + x = (x0- y0, x1- y1, x2- y2, x3- y3)
* -x = (-x0, -x1, -x2, -x3)

===Scalar multiplication===
The same goes for multiplication with and division by a scalar value ''a'' and "scalar multiplication" of two quaternions ''x'' and ''y'':
* a · x = x · a = (a · x0, a · x1, a · x2, a · x3)
* x / a = x · 1/a = 1/a · x = x · a-1 = (x0 / a, x1 / a, x2 / a, x3 / a)
* x · y = y · x = x0· y0 + x1· y1 + x2· y2 + x3· y3

===Conjugate quaternion===
Quaterions are "hypercomplex" numbers. Like "normal" complex numbers with one imarinary component, quaternions define the conjugate quaternion x or x*:
* x = (x0, -x1, -x2, -x3)

===Hamilton product===
A quite unique operation of quaternions is the Hamilton product, i.e. the multiplication of two quaternions that yields a quaternion again. This one is special, because unlike addition or scalar product, it is ''not'' commutative.
* x y = (x0· y0 - x1· y1 - x2· y2 - x3· y3, x0· y1 + x1· y0 + x2· y3 - x3· y2, x0· y2 - x1· y3 + x2· y0 + x3· y1, x0· y3 + x1· y2 - x2· y1 + x3· y0)
Now that looks vile. But if you express the quaternions as a combination of a scalar and a vector part, i.e. x = (x0, xV), you can express quaternion multiplication using the 3D vector scalar product "·", cross product "⨯" and vector multiplication by a scalar value:
* x y = (x0, xV)(y0, yV) = (x0y0- xV· yV, x0yV + xVy0+ xV⨯ yV)
This representation also easily shows that x y ≠ y x, because xV⨯ yV = -(yV⨯ xV).

Now if you recall that a "real quaternion" (vector part zero) is essentially the same as a real number, you can easily see that the quaterion scalar product is basically a special, commutative case of the Hamilton product. In fact, even the multiplication of real numbers could be seen a special case of the Hamilton product, which both quaternions having zero vector parts.

Another important special case is the Hamilton product of two unit quaterions: The result of such a multiplication is a unit quaternion again.

===Norm===
A quaternion's norm ||x||2 (its "length") is defined similarly to a vector's length:
* ||x||2 = x x = x x = x · x = x02+ x12+ x22+ x32
The value ||x|| is called the length or absolute value of the quaternion. Its square is equal to the scalar product of the quaternion with itself or the Hamilton product with its conjugate quaternion. A quaternion with the norm 1 is called a '''unit quaternion'''. Multiplying a quaternion by its conjugate results in the vector part becoming zero, which is why the resulting quaternion in the above equation can be considered a scalar number. (Remember that quaternions are hypercomplex numbers, not euclidean vectors. Real numbers are valid quaternion values with the vector part being zero.)

===Inverse===
A quaternion's multiplicative inverse, the reciprocal, x-1 is defined as the value that satisfies the equation x x-1 = 1:
* x-1 = x / (x x) = x / ||x||2
Note that the fractional notation is avoided if the denominator is not a real number because the notation itself is ambiguous since it does not specify if the denominator's reciprocal must be multiplied to the left or to the right of the numerator and quaternion multiplication is not commutative.

An important special case of the inverse are unit quaterions. Because their norm is already 1, the inverse of a unit quaterion is the same as the conjugate of that unit quaternion.

==Quaternion rotation==
The basis for expression rotations using quaternions are unit quaternions, i.e. quaternions with a length of 1, and pure imaginary quaternions, i.e. quaternions of the form (0, x1, x2, x3). Pure imaginary quaternions are used to represent vectors that will be rotated around the origin in some way, while unit quaternions define the rotation axis and angle. To apply a rotation defined by quaternion r to a vector defined by quaternion v, all you need to do is calculate the quaternion product r v r-1.

A property of quaternion multiplication is that the length of the resulting quaternion is the same as the product of the lengths of the two original quaternions. Consequently the product of two unit quaternions will be another unit quaternions. If those two unit quaternions represent 3D rotations, the resulting unit quaternion will represent the combination of these two rotations in the reverse order. The product r1 r2 represents a rotation achieved by first applying r2, then r1.

The vector to rotate can be converted to a quaternion simply by using the vector as the quaternion's vector part and zero as the scalar part. A rotation quaternion is calculated from a rotation axis and an angle. Given the rotation axis as unit vector u and the rotation angle α between 0 and 2π, the rotation quaternion r is calculated as r = (cos α/2, u sin α/2).

==UnrealScript functions==
The {{classgames|Object|ne=UE1}} class provides several functions and (in UE3) operators for working with quaternions. It defines the [[struct]] '''Quat''' with the components W, X, Y and Z as data type for a quaternion value. Unreal Engine 3 also defines the binary operators <code>+</code> and <code>-</code>, and like with every struct you can compare Quat values for equality and inequality with the <code>==</code> and <code>!=</code> operators.

The Quat struct type is subject to data reduction during replication. The engine assumes that you replicate only unit quaternions and only replicates the X, Y and Z components. The W component will be calculated on the remote side to get a unit quaternion again.

Quaternion rotation is used in rigid body physics calculations both in Unreal Engine 2 (PHYS_Karma) and Unreal Engine 3 (PHYS_RigidBody). The rigid body physics state of an actor is composed of a vector for the location, a quaternion for the rotation and two vectors for linear and angular velocity.

===QuatProduct(Quat, Quat)===
Calculates the Hamilton product of the two quaternions and returns the resulting quaternion value.

===QuatDot(Quat, Quat)===
Calculates the scalar product of the two quaternions and returns the resulting float value. This function is not available in Unreal Engine 2.

===QuatInvert(Quat)===
Returns the conjugate quaternion. Note that due to x-1 = x / ||x||2 the conjugate quaternion of a unit quaternion also is its reciprocal.

===QuatRotateVector(Quat, Vector)===
Rotates the specified vector by the given rotation quaternion and returns the resulting vector value. Note that the result will only be actually the rotated vector if the quaternion is a unit quaternion.

===QuatFindBetween(Vector, Vector)===
Calculates the quaternion that will rotate the first vector onto the second. It does so by calculating the rotation axis and angle between the vectors using the cross product and scalar product. Note that it short-circuits if the cross product is zero. In that case, whether the vectors point in the same or opposite directions, it always returns the identity quaternion (1,0,0,0), even though opposite direction vectors would require a rotation by 180° around an arbitrary rotation axis perpendicular to the vectors.

===QuatFromAxisAndAngle(Vector, float)===
Creates a rotation quaternion from the specifies axis vector and rotation angle in radians. The vector will be normalized for this calculation but must not be zero.

===QuatFromRotator(Rotator)===
Calculates a rotation quaternion that represents the same rotation as the specified [[Rotator]] value.

===QuatToRotator(Quat)===
Calculates a Rotator value that represents the same rotation as the specified rotation quaternion. This basically applies the quaternion rotation to the X, Y and Z axis vectors and uses the OrthoRotation function on the resulting vectors to calculate the Rotator value.

===QuatSlerp(Quat, Quat, float)===
Performs '''s'''pherical '''l'''inear int'''erp'''olation on the two rotation quaternions, using the float value as blend alpha. A value of 0.0 maps to the first quaternion, a value of 1.0 to the second, while 0.5 is halfway between them.

{{navbox unrealscript}}

Legacy:Another Look At Replication

2016-01-08T06:09:10Z

Wormbo:

==The Meaning Of The Replication Block==

<uscript>
replication
{
reliable if( Role == ROLE_Authority )
somevar;
reliable if( Role < ROLE_Authority )
someInputVar;
}
</uscript>

The first part of the replication block here is saying, if 'somevar' changes on the server, then the server should tell others about it.

The second part says if 'someInputVar' changes on the client, then the client will send that data back to the server.

When writing your replication statements, your conditional check is a specification of who should be SENDING the data, and then that data will be sent to everyone applicable.

I'm guessing this means that the server will always send to the owner of the actor, and maybe even ALL clients.

On the other hand, Clients can ONLY send data to the server.

'''MtTracer:''' As far as I know variables are not necessarily sent directly after they changed. Replication happens frequently but you can't tell when exactly. Only bNetDirty can be used to see if at least one property of this a class has been changed since the last replication check. Second, the server will allways send its variables to every "copy" of this actor on all clients except you used bNetOwner in the condition check.

<uscript>
replication
{
reliable if( ROLE == ROLE_Authority )
ServerVersionOfSomeImportantValueTheClientIsGoingToChange;
reliable if( ROLE < ROLE_Authority )
NotifyServer, SomeImportantValueTheClientIsGoingToChange;
}

simulated function MyClientSideFunc()
{
SomeImportantValueTheClientIsGoingToChange++;
NotifyServer();
}

function NotifyServer()
{
if( SomeImportantValueTheClientIsGoingToChange == NOT_A_PROBLEMATIC_CHANGE )
ServerVersionOfSomeIMportantValueTheClientIsGoingToChange=SomeImportantValueTheClientIsGoingToChange;
}

simulated event DrawHUD(Canvas C)
{
C.DrawText("Client Value specified is: "@ServerVersionOfSomeImportantValueTheClientIsGoingToChange);
}

</uscript>

Now what's going on here, is that the client is going to change SomeIMportantValueTheClientIsGoingToChange, and call NotifyServer.

This call to notify server is going to be called on the ServerMachine, both because it's non-simulated, so it can't execute on the client, and because we are replicating this function from the client to the server.

in NotifyServer The server will allow the change and set it's version of this variable, 'SeverVersionOfSomeIMportantValueTheClientIsGoingToChange' to the client variables value.

Now that this has happened, the drawhud function is going to draw the value of the server's version of the variable to the clients hud during updates.

This is simply an example to get the point across. Specifically, i have not tested to see whether SomeImportantValueTheClientIsGoingToChange will take it's new, client modified value, before NotifyServer is called and the value is assigned.

This understanding has fixed some of my recent problems so i hope it helps you too.

==Comments==

'''Tarquin:''' Perhaps this can be folded into [[Legacy:Introduction To Replication|Introduction To Replication]]?

'''Solid Snake:''' Fixed a spelling mistake for those who cut-copy code from places, and also it may be better to just use A, B instead of really long labels for the sake of readability?

'''Mychaeel:''' ''Especially'' for sake of readability I'm particularly fond of well-crafted, long symbol names... though I have to admit that the ones used here aren't terribly well-crafted. They're just a string of [[Wiki:WordsSmashedTogetherLikeSo|WordsSmashedTogetherLikeSo]].

'''Sweavo:''' Agree that this should be folded-in, also that human-meaningful names are better than A and B

'''*mGm*Lizard:''' Does this page apply to [[Unreal Tournament 2004|UT2004]]?

'''Wormbo:''' It talks about variables being replicated from client to server, a feature not present in UE2, so it's likely related only to UE1 games.
----

[[:Category:Legacy To Do]] – This needs merged into the grand topic of [[Legacy:Replication|Replication]]. See [[Legacy:Replication/Discussing|Replication/Discussing]]
[[Category:Legacy To Do|{{PAGENAME}}]]

Talk:Main Page

2015-12-30T00:34:29Z

Wormbo: /* File Reference List */ file list -> unreal admin wiki?

== UnrealScript API ==
Wouldnt it be more useful to have some sort of contents for API documentation?

*API?
**[[Commandlet]]
**Flow of events [[Legacy:Game_Event_Glossary]]
***Timers / Tick - In UE3 these can take a function call (reference), previously timer was simply one function.
***Main Foreach AllIterators.
***[[What_happens_at_map_startup]] | [[Legacy:Chain_Of_Events_At_Level_Startup]]
***[[What_happens_when_an_Actor_is_spawned]] | [[Legacy:Chain_Of_Events_When_Spawning_Actors]]
***[[What_happens_when_an_Actor_is_destroyed]]
***[[Legacy:Chain_Of_Events_When_A_Player_Logs_In]]
**Components3
*[[Legacy:Creating_Actors_And_Objects]]
**[[Spawn]] / [[New]]
*[[Destroying_Objects]] - [[Legacy:Garbage_Collection|Garbage Collection]]
*[[Legacy:Object_Pool|Object Pools]]
*Maths
**[[Legacy:UnrealScript_Vector_Maths]]

So I pulled this list from the references talk page as its not really relevant 'directly' to the unreal script language but its classes. Not having a contents page makes it tricky to traverse, I understand that the class pages are much better documented then in the past but as an eg, spawn(), if I didnt know to look for it I wouldnt find it. So Im proposing a contents, the above is no where near a suggestion its just a stub of pages that could go into the API documentation contents, cool. --[[User:00zX|00zX]] 03:40, 22 April 2010 (UTC)

== General layout ==

I've tried to come up with a compact initial layout and topic list. Suggestions for improvements are welcome. [[User:Wormbo|Wormbo]] 06:31, 13 March 2008 (EDT)

Actually, we need to come up with an easy-to-browse structure for overview pages of the various parts of Unreal modding. The problem here will be that either this kind of page tends to get too long or there are too many pages to click through before reaching actual content. We need to find a good mix between an sophisticated structure and quick access. The topic pages can be accompanied by [[Project:categories|categories]], navigation/info boxes (an example can be found e.g. on [[Literals]]) and disambiguation links/pages for when a user uses the Go button of the search box in the sidebar. I hope this will give you an overview of the new tools we can use to structure the Unreal Wiki. -[[User:Wormbo|Wormbo]] 07:58, 16 April 2008 (UTC)

I think we can now all agree this should have been discussed openly and decided much earlier, before the switch to MediaWiki and the subsequent disconnect with Legacy content. This discussion will likely last a while and not get the input of the entire wiki community. Seeing as I was an instrumental contributor of the old organization (which has been widely criticized as poor or no organization), I will step back, keep an eye on the progress and wait for the dust to settle. Good luck. -[[User:SuperApe|SuperApe]] 08:57 PST, 16 April 2008

Under the UnrealScript Reference topics, seeing 'Programming tutorials' seems a little out of place. Since most if not all the programming tutorials we have here will deal with UnrealScript, why not change it and the category to UnrealScript Tutorials? -[[User:DalinSeivewright|DalinSeivewright]] 15:14, 17 April 2008 (UTC)

These category things are working arnt they? Ive been around the site acouple of times now and I dont think Ive seen anything in any of the expanded tree's. Just wondering anyways, perhaps we could get some templates in there with correct names for the time being. -[[User:OlympusMons|OlympusMons]] 22:49, 17 April 2008 (UTC)

Those tree widgets only show subcategories, not pages or media. Just imagine [[:Category:UT2004-specific classes]] displaying all old UT2004 classes when you expand its subcategory [[:Category:Legacy Class (UT2004)]]! If you mean the actual categories, don't worry. I'll import the wikified class pages for UT, UT2003/4, UT3 and UE2Runtime some time this week. -[[User:Wormbo|Wormbo]] 08:35, 21 April 2008 (UTC)

Yeah I noticed that an hour or so after making that comment, I thought classes were meant to be shown in the category class tree's but they arnt, it seems to function more like a search criterea. Yeah hope things are going well on the new wikifier, should save alot of time. :)
Actually on the Topic of class tree's since Im there, whats going to happen in that respect now? Are we going to have a class tree page anymore? I imagine alot can be done with tree views now so Id wonder if it is possible to have a class tree which is actually expandable/collapsable now, since the categories dont show the classes right under their package or superclass etc -[[User:OlympusMons|OlympusMons]] 23:29, 21 April 2008 (UTC)

:Double post looolz, anyways to expand on class tree's I had a play over here: [[Unreal_Wiki:Sandbox|Sandbox]] but I think it'll need its own template or something and Im not well versed on this new wiki stuff just yet. This category list shows the pages though under the categories they fall but I couldnt get the parent class showing as a category which is why I thought it'd need a template. -[[User:OlympusMons|OlympusMons]] 16:51, 27 April 2008 (UTC)

== New wiki software / Organization ==
Various people have had questions, comments, or criticisms of this move to MediaWiki. This seems as good a place as any to discuss it, so feel free to add anything here. – [[User:Haarg|Haarg]] 21:32, 3 April 2008 (UTC)

:Well I guess my biggest concern is the wealth of existing information (namely the tutorials and class hierarchy pages) that we can't simply move over. Most if not all the pages have had at least one contributor to the page that has done at least a minor edit. Then there's the problem of not having a complete history of the older pages so while it may appear that only one individual has worked on a given page, the truth could be that at least two have worked on it but the history of the page has been lost. Then theres the problem of what we can do with new content for the older engines as we cannot add new content to these legacy pages. IMO, the class hierarchy at least could be moved over as most of the pages are simply descriptions of what the class does (which really, Copyrights should have no hold over because there's only so many ways you can describe what a class is responsible for) and have listings for each method and variable and what they're used for.

:If that really is not an option then we could go through class by class and (re-) create a class page for each of them by source. So we could have a category for each game and have a hierarchy of classes from each package. It '''would''' take a fair bit of time to complete and a decent format would need to be made up. I personally didn't like how the old formats were set up. It seemed like too much information was being thrown at you for classes such as Actor, where there are a lot of variables and methods to go through. I guess we'd have to look at how much more information we could add in the end. I'm not sure how 'definitive' our class pages were, but I'm positive we didn't have many pages for certain classes.

:On the topic of tutorials, is there any reason why we can't re-write them? If a tutorial explains how to make a new weapon based on the shock rifle (which has been over done already) we could just reinvent the wheel. The other more advanced tutorials (such as the RPG Class tutorials) could be re-written with a similar basis.

:In the end, I think keeping the older content up-to-date and easy to find/navigate through is important as many level designers and modders most likely have not moved over to UE3 and UE2 still has plenty of life left in it.

:-[[User:DalinSeivewright|DalinSeivewright]] 12:03, 4 April 2008 (UTC)
::Most of the class hierarchy could be moved over or recreated pretty simply. As for tutorials, rewriting them is probably the best solution. While that may seem like wasted effort, I don't see a better solution given the licensing issues. – [[User:Haarg|Haarg]] 17:17, 5 April 2008 (UTC)
:wow. Unreal Wiki had a makeover... This will be confusing for a while...--[[User:JeffMOD|JeffMOD]] 14:56, 5 April 2008 (UTC)
:A comment on user accounts: It probably could have been explained better, but the user accounts from the old wiki weren't converted to the new software. First, I somewhat doubt it would have been possibly technically But mainly, there was barely any information attached to the old accounts that have been worth keeping. So everyone has to create new user accounts. Additionally, anonymous edits are turned off. I would be interested in feedback on that as well. – [[User:Haarg|Haarg]] 17:17, 5 April 2008 (UTC)
::I think its a great idea. Its a good anti-spam addition that works well for the most part, although it could end up generating a lot of accounts that would only be used once (as I've found a lot of people often to go to a site where they need to sign up to contribute and only ever change one thing they've found). Also, spam bots have been known to sign up a lot so perhaps you could add CAPTCHA to the account creation process. -[[User:DalinSeivewright|DalinSeivewright]] 02:30, 6 April 2008 (UTC)
:::I don't think we need to add a captcha at this point, but that could be revisited if spam becomes a problem. – [[User:Haarg|Haarg]] 02:36, 6 April 2008 (UTC)

Two things. Having the Legacy article show up in the search kind of makes it look incredibly messy, unorganized and hard to follow. I understand that its important to stress that Users probably shouldn't do major edits to Legacy pages but somehow hiding the Legacy part of the article name would help things considerably.

Secondly I was comparing the Actor class of UT2003 with that of UT2004 and there are several differences in each. I think we should have at least one Actor page for each generation but what about games within the same generation? Should we have seperate Actor pages for UT2003 and UT2004 within the UE2 namespace or UT2003/UT2004 namespaces or should we have one full page for UT2004 and have a seperate page for the Actor class in UT2003 that just sites the major differences? -[[User:DalinSeivewright|DalinSeivewright]] 01:32, 15 April 2008 (UTC)
:Well on the topic of UE2 Id think the best option might be to have a seperate section relating to UE2.5 since its an upgrade on the engine. Both UT2003 and UT2004 are UE2 though but other engines picked up support at UE2.5 where some are based on UE2. I do know there was alittle bit of a hastle with the class tree pages because it contained info from both UE2-2.5 so each difference had to be tagged. I guess it wasnt so bad since some classes are identical between the two, the last idea sounds good to me to do full page on UT2004's Actor and a differences page for UT2003. - [[User:OlympusMons|OlympusMons]]

:::I actually change my mind. I think we should have an actor page for each version of the engine/game. This would be considerably more work (unless Wormbo finishes his class wikifier?) but it would be much 'cleaner' and dare I say sexier. Plus users won't be too confused on whether or not their on the right page if the page just sites the differences. -[[User:DalinSeivewright|DalinSeivewright]] 00:11, 17 April 2008 (UTC)

::::Might be the go hey since there are sometimes differences between builds as well so it might get very confusing later, duplicating material isnt too good but I dont think it can be helped much since of the nature of UE. -[[User:OlympusMons|OlympusMons]] 22:51, 17 April 2008 (UTC)

:::I agree with Dalin here. Each "game" (including UE2Runtime) gets its own set of class pages and corresponding categories. If the classes really have exactly the same content, we can take advantage of the template features and simply include the newest game's version of the page on all older games' versions of the same page. I already demonstrated this on [[UE2:DMRosterBeatTeam (UT2003)]], which only includes the content from [[UE2:DMRosterBeatTeam (UT2004)]]. The templates [[Template:Infobox class]] (and [[Template:Infobox class part]]) and [[Template:samegame]] used there automatically set up links to point to pages of the same game. On a semi-related note: Do we want to document defaultproperties, possibly including subobjects, on the class pages? -[[User:Wormbo|Wormbo]] 08:35, 21 April 2008 (UTC)

::::I'm in favor of having any documentation of the default properties in where the variables are documented (if at all). It would seem reasonable to have the 'default' or accepted values for a given variable where we've explained what the variable is for. I think subobjects should be included too, just as long as we can have a seperate page for that sub-object if it is really important. For example, the KPhysics object in xPawn. Without it, your Pawn fails. -[[User:DalinSeivewright|DalinSeivewright]] 05:49, 22 April 2008 (UTC)

::::Please have a look at [[UE3:UIObject (UT3)]], I've updated it with the basic default value and subobject output of the wikifier. I still need to add special parsing for struct values to link any enums or subobjects used there. Suggestions about the output are welcome. -[[User:Wormbo|Wormbo]] 09:23, 27 April 2008 (UTC)

== Mod ideas ==

I dont know where to add mod ideas...

The mod ideas section didn't really work out on the old wiki, IMHO. Would it really make sense to revive that? -[[User:Wormbo|Wormbo]] 05:54, 25 April 2008 (UTC)
:I was actually thinking the same thing and wasn't going to add it to the main page, but then I thought I'd add it anyways and see what anyone else thought. The old Mod ideas was an okay source for ideas but it ended up being a list of abandoned pages with half being discussions on the Mod idea itself and the other half being discussions on the progress of the mod, as if it was no longer an open source idea but being worked on. I'm fine with not reviving the page, but where would these mod ideas go now? -[[User:DalinSeivewright|DalinSeivewright]] 06:26, 25 April 2008 (UTC)
::Better leave mod ideas to ppl's own wiki pages -[[User:0 Kelvin|0 Kelvin]]
:::That's a pretty good idea actually. There could be a category like [[:Category:Mod ideas]] or something similar, and it could go over what to have in mind of you are proposing a mod idea. Ideas could then be posted as sub-pages of user pages. If an idea actually took off, it could be moved into a different namespace easily. – [[User:Haarg|Haarg]] 15:47, 25 April 2008 (UTC)
::::Lets go with that then :) What about Licensing issues though? Will the 'concept' of Mod Ideas have to be reworked? If a user has a great concept and someone came and used that idea down to the exact details would there be any problems/need to cite references etc. ? I'm pretty sure copyright doesn't have a hold over 'ideas', although I could be wrong. -[[User:DalinSeivewright|DalinSeivewright]] 16:09, 25 April 2008 (UTC)
::::Isn't the entire point of posting mod ideas that ''others'' should pick them up? -[[User:Wormbo|Wormbo]] 16:59, 25 April 2008 (UTC)
:::::Yes of course, but since its under the Wiki license I'm simply wondering if there should be a seperate license for the idea pages, or if there would even be a need for that. I'm guessing by your comment, there should be no problem with the licensing then? :) -[[User:DalinSeivewright|DalinSeivewright]] 18:23, 25 April 2008 (UTC)

I've removed the [[Modding ideas]] link from the main page. That page should really be dissolved and the individual ideas should be posted on the contributing users' personal pages. Once that is done, [[:Category:Mod ideas]] could be linked from [[Modding overview]], but not from the main page. —[[User:Wormbo|Wormbo]] 20:16, 21 November 2008 (UTC)

==Category link description==
Do the Wiki Categories currently support descriptions for each page associated to the category? What I mean is, is there currently a way to associate a description of a page within a category and have that description appear in the list of pages for said category? For example:
<pre>
A
[[Apple]] - This page describes what an apple is.
O
[[Orange]] - This page describes what an orange is.
</pre>
These descriptions would be added on the page with perhaps a little tag? I'm just curious and don't really feel they're neccesary... at least at the moment. -[[User:DalinSeivewright|DalinSeivewright]] 16:23, 25 April 2008 (UTC)

No, that's not supported. This type of description needs to go in the page text, either of the category page or a more suitable topic page. -[[User:Wormbo|Wormbo]] 16:54, 25 April 2008 (UTC)

Some form of this could be done using a DPL report:<dpl>
category = Custom UE2-specific classes
include={Infobox class}:parent1
includematch=/./
secseparators= \n- Subclass of ,
</dpl>
But that would be built as a specific list, and not part of the general category page. – [[User:Haarg|Haarg]] 17:49, 25 April 2008 (UTC)

== 3rd Party / open source scripts ==

Where do they go? (O Kelvin)

: As a page with the the appropriate namespace and page name. [[UE1:RJumpPad]] for example. With a class infobox, it will be added to the appropriate categories. – [[User:Haarg|Haarg]] 23:30, 27 April 2008 (UTC)

:: Ops... I made edits to the Legacy:Third party components page -_- [[User:0 Kelvin]]
:: How about adding a "Projects" starting point ? It would be ideal for grouping all the third-party code detailed on the wiki and make it easily accessible. I mean, think of those people who are getting started with unrealscript. Documentation sometimes isn't enough and snippets of code could serve as examples. At the moment, it's a pain finding anything and one usually has to type random phrases in Google to get access to anything interesting. --[[User:Azura|Azura]] 01:14, 6 April 2009 (UTC)

== Battering Ram ==

Well, this is the First Time i ever wrote anything on here, and it's actually more of a question, or plea for help, than anything else. I am NOT a programmer, but am very familiar with most of the language having mapped since Doom, not Doom3, Doom... but I have come across an interesting problem I can't solve.

I am trying to make a vehicle, with a Battering Ram. I have the Vehicle, what I need is the Battering Ram. My idea was to take the static mesh from the Shock Tank Shield, resized and converted to my vehicle static mesh package, and use it as a Projectile, that travels a very short distance, at a high rate of speed and Batters whatever it hits and stops projectiles like a shield. It works, my problem is though, when it is aimed low, it disappears. It is still there as far as hammering actors, and other momentum/damage effects, but there is no visibility.

I've tried making it in over 5 different ways now, projectile, emitter, pawn, actor, u name it, i tried it, all worked but with same disappearing act. I suspect it has something to do with collision size, but i've tried it with or without, and nothing seems to work. I used the Shield Shader as the Texture, Have collision of texture true, tried using other meshes, even a square, Even recoded the whole gun to use the shield from the Shock Tank, with redone emitter effect just to see and even the emitter effect said "GoodBye!".

I'd put up the code I last used but it's basically the Projectile Code, altered to launch the static mesh and right now has every collision property i could find, in defaults, set to true.

So if someone finds the idea interesting, or you're just bored, ANY help is Good Help...

:Honestly, for "interactive" modding help you should really ask in a forum. The Unreal Wiki is more of a reference site. If you are looking for or want to help writing tutorials, then this is the place for you. —[[User:Wormbo|Wormbo]] 18:19, 9 May 2009 (UTC)

== IRC ==

Shouldn't we have some mention about the Unreal IRC channels such as #UnrealScript and #UnrealWiki? on the main page, perhaps there is and i didn't see it but in that case it should be moved so people will see it. --Eliot 22:39, 17 July 2010 (UTC)

== "Modding" section ==

What exactly is the point of that section? I mean, modding is the act of modifying a game. You can do so by creating custom levels ("Mapping"), custom models ("Modeling") or changing the rules on any scale from small additions to a totally new game ("Programming"). And apart from that obvious ambiguity - check out [[Modding overview], it's a joke. —[[User:Wormbo|Wormbo]]

:yeah I dont know what the purpose of it was (I went ahead and removed it, revert if needed anyways), maybe it was some sort of section to combine all three sections but this can be done in a much better fashion if required in tutorials. Using a basic proceedure approach to tutorials though each of the smaller tutorials would reside in their apropriate sections, mapping, modeling or programming, cool --[[User:00zX|00zX]] 08:57, 2 August 2010 (UTC)

==IRC?==
What the heck does IRC stand for, and why don't any of the links do anything when I click them? Yours truly [[User:UnrealMuskrat|UnrealMuskrat]] 00:06, 20 June 2014 (UTC)

:IRC means [[wp:Internet Relay Chat|Internet Relay Chat]]. It's an old, yet still quite popular chat protocol for which you need a special client. Thunderbird can do it natively, there's ChatZilla for Firefox, there are many dedicated programs like mIRC and multi-protocol chat programs like Miranda, Pidgin or Trillian. —[[User:Wormbo|Wormbo]] 14:36, 20 June 2014 (UTC)

Cool, chats are awesome, pretty cool how you've got 4 to choose from. I'll have to learn how to get these things working for me, I love to chat. Yours truly [[User:UnrealMuskrat|UnrealMuskrat]] 21:50, 21 June 2014 (UTC)

== File Reference List ==
What I need for publishing map packages is a list of stock and non stock files for UT with respect to the UT versions and addons/bonus packs. Usually I use [http://www.birrabrothers.com/drac/index.php?dsps=145 birrabrothers.com] and a clean fresh UT installation to find that out. Wouldn't be the Wiki a matching place for such a collection? --[[User:SeriousBarbie|SeriousBarbie]] ([[User talk:SeriousBarbie|talk]]) 18:58, 29 December 2015 (EST)
:IIRC we do have such lists for particular types of packages. A complete file list is probably more admin-related than modding-related and thus should maybe belong in the [[uadmin:|Unreal Admin Wiki]]. —[[User:Wormbo|Wormbo]] 19:34, 29 December 2015 (EST)

Legacy talk:DistanceViewTrigger

2015-12-25T09:05:28Z

Wormbo: not quite all Pawns, but most of them

== Only Bots? ==
From what I see in the code, not only Bots are concerned but all Pawns? --[[User:SeriousBarbie|SeriousBarbie]] ([[User talk:SeriousBarbie|talk]]) 21:15, 24 December 2015 (EST)

:Keep in mind this page may have been written from a UT perspective and the class is part of the Botpack package. You can see it on CTF-Face, where DistanceViewTriggers are placed on the top of the towers, which are triggered by TeamTriggers on the top and bottom of the other tower. Yes, should also work on subclasses of [[Legacy:Bots]] and [[Legacy:ScriptedPawn]], because it triggers the affected Pawns and only those three Pawn subclasses implement Trigger() logic, but those other Pawn types are less likely to do sniping tasks, which is what the DistanceViewTrigger seems to be designed for. —[[User:Wormbo|Wormbo]] 04:05, 25 December 2015 (EST)

Talk:Constants

2015-11-20T15:28:51Z

Wormbo: ah yes, the UScript compiler...

== Constants with same name in different functions (UE1) ==

The UE1 compiler UCC.EXE does not support constants with the same name in different functions.

Example:
<pre>class test expands Object;

function Nothing1() {
const CDebug = true;
return;
}

function Nothing2() {
const CDebug = true;
return;
}</pre>
On compiling this, a GPF occurs:

----

Parsing Test
General protection fault!

History: FScriptCompiler::CompileConst <- Const <- FScriptCompiler::CompileDeclaration <- FScriptCompiler::CompileStatement <- FirstPass <- TryCompile <- FScriptCompiler::CompileScript <- (Class BarbiesWorld.Test, Pass 0, Line 9) <- MakeScript <- MakeScript <- DoScripts <- UEditorEngine::MakeScripts <- UMakeCommandlet::Main

Exiting due to error

----
--[[User:SeriousBarbie|SeriousBarbie]] ([[User talk:SeriousBarbie|talk]]) 23:33, 18 November 2015 (EST)

:That's because it doesn't really apply the scpoing concept to constants. They are always global to the class. —[[User:Wormbo|Wormbo]] 00:11, 19 November 2015 (EST)
::I did not find any scope description in the article - therefore I found it worth to mention here. (BTW: UScript is the first language I saw where the scope of local definitions extends that area.) --[[User:SeriousBarbie|SeriousBarbie]] ([[User talk:SeriousBarbie|talk]]) 00:29, 19 November 2015 (EST)
:Well, the UnrealScript compiler is really basic compared to other languages - and it's written in really messy code. All these weird things are essentially compiler bugs. —[[User:Wormbo|Wormbo]] 10:28, 20 November 2015 (EST)

Talk:Constants

2015-11-19T05:11:25Z

Wormbo: consts are always global

Unreal Wiki talk:About

2015-11-05T16:40:36Z

Wormbo: /* Error messages on pages, eg "Moon3" */ Thanks for reporting

== Error messages on pages, eg "Moon3" ==
On visiting [[UE1:Moon3_%28UT%29]] I get the following error message: 
<code>Extension:DynamicPageList (DPL), version 3.0.7: Error: Too many categories! Maximum: 4. Help: increase $dplSettings['maxCategoryCount'] to specify more categories or set $dplSettings['allowUnlimitedCategories'] = true; for no limitation. (Set the variable in the wiki's LocalSettings.php configuration file.)</code> 
Browsing parent classes of "Moon3" creates error messages, too. --[[User:SeriousBarbie|SeriousBarbie]] ([[User talk:SeriousBarbie|talk]]) 10:15, 5 November 2015 (EST)
:Thanks for reporting, I'll let [[User:Sir Brizz|Sir Brizz]] know. For future reference: Please report this kind of issue in the forums. (I also fixed the sidebar link to that.) —[[User:Wormbo|Wormbo]] 11:40, 5 November 2015 (EST)

MediaWiki:Sidebar

2015-11-05T16:37:52Z

Wormbo: updated forums link and split into general/technical to encourage general bug reporting there

Legacy talk:SpawnNotify

2015-10-02T20:40:19Z

Wormbo:

== How to get it work ==
It took me some time to find out that a SpawnNotify has to be spawned from somewhere to get it work. Maybe it could be mentioned in the article. --[[User:SeriousBarbie|SeriousBarbie]] ([[User talk:SeriousBarbie|talk]]) 12:58, 2 October 2015 (EDT)

:There's really nothing special about it. You spawn it and it auto-registers itself in its PostBeginPlay(). In other words, all you need to do is implement SpawnNotification() in your subclass and specify an ActorClass to receive notifications for. The fact ''that'' you have to spawn it should be obvious from the fact that other things are somehow specified as well. You almost never write code and it somehow takes effect automagically, it's always registered somehow somewhere. —[[User:Wormbo|Wormbo]] 16:40, 2 October 2015 (EDT)

Talk:Everything you ever wanted to know about replication (but were afraid to ask)

2015-10-01T20:55:35Z

Wormbo: /* Is a replicated function executed in tick? */ UnrealScript is single-threaded, received functions run synchronously

Ah sorry for changing that i thought dynamic would make more sense and have still the same meaning so i dealt with it just like typos and adding categories to someone else his article. --Eliot 19:28, 13 August 2010 (UTC)

== So if I get this right.... ==

Ok if I understand this correctly:

1. The <uscript>replication{}</uscript> block is used to update variables on the client(s). When this happens, depends on the variable used in the if-statement (ie bNetInitial) surrounding the variable.

2. To execute something after a variable is updated, mark the variable for replication notifications using 'repnotify': <uscript>var repnotify int myRepInt</uscript>
This calls the <uscript>simulated event ReplicatedEvent(name VarName)</uscript> function.
<uscript>simulated event ReplicatedEvent(name VarName)
{
if(VarName == 'myRepInt')
{
myActionOnRepIntChange();
}
else
{
super.ReplicatedEvent(VarName);
}
}</uscript>

3. If we execute a function on the client (function has to be marked simulated for this) and it needs to be done on the server aswell (to update/notify change to all others),
we need a reliable (or unreliable if it's not that big of a deal if it doesn't happen) server function (containing the same logic as the client function).
<uscript>
exec setMyRepInt()
{
initMyRepInt();
}

simulated function initMyRepInt()
{
myRepInt = 10;

if(Role < Role_Authority)
{
serverInitMyRepInt();
}
}

reliable server function serverInitMyRepInt()
{
myRepInt = 10;
}
</uscript>

I hope this is correct and that if it is the code may enhance the tutorial/QA/overview of replication for others.
{{unsigned|Omar007|19:49, 12 October 2011}}

----

Yes, that's correct, but it's highly UE3-specific. In earlier engine generations replication of functions is specified in the replication block as well and repnotify/ReplicatedEvent() do not exist. —[[User:Wormbo|Wormbo]] 19:41, 12 October 2011 (UTC)

----

Yes that is true. I wrote this with the UDK replication syntax in mind as that is what I needed to know for sure ;)

Greatly appreciate you writing this document and confirming my verification question.

--[[User:Omar007|Omar007]] 21:06, 12 October 2011 (UTC)

==Name type==
Is it just me doing something wrong or is the replicating of Name variable types not possible? When I send a Name variable from server to client the client may receive 'bTrackMouse' when the server actually sent 'foo', it seems that the engine just sends the name index instead of sending the new name string for the client to register to its internal Names list, either that or I am doing it wrong?
--[[User:Eliot|Eliot]] 12:31, 10 March 2014 (UTC)

:Replicating names should work, as long as you don't use names from dynamically loaded packages or even names created at runtime. Names are just sent as name table index. —[[User:Wormbo|Wormbo]] 17:29, 10 March 2014 (UTC)

::Thanks for confirming my suspicion Wormbo!, that explains why QueueAnnouncement works. --[[User:Eliot|Eliot]] 18:50, 10 March 2014 (UTC)

== Is a replicated function executed in tick? ==

I've been looking for this information for some time now, but can't find it anywhere.
When a client calls the server with a replicated function, does the server immediately start the execution (ie: in a separate thread?) as soon as it gets the client's call, or does it wait for the next tick to execute the function?

If the function runs in a separate thread, is there any issue accessing and modifying variables?
In general, is there any behavior that could cause problems and should be avoided in replicated functions? (should the function function be lightweight, with minimal impact? Or is there no real restriction?)

Thanks!
--[[User:Benit2|Benit2]] ([[User talk:Benit2|talk]]) 09:52, 30 September 2015 (EDT)

:UnrealScript is strictly single-threaded. (There may be parallel physics updates in UE3, but I'm not sure if they would cause any asynchronous UnrealScript execution.) Replicated functions are executed when the receiving party polls the data during the connection tick, and thus run synchronously in relation to other UnrealScript functions on the executing client or server instance. —[[User:Wormbo|Wormbo]] 16:55, 1 October 2015 (EDT)

Talk:Variables

2015-09-16T16:53:25Z

Wormbo: sorry, it's for struict member modifiers

== Explanation of superscript "S" missing ==
Some modifiers are superscripted by "S", but the explanation of it is missing in the "Infobox EngineVersion". Probably it got lost with [http://wiki.beyondunreal.com/Variables?diff=prev&oldid=43989 this change]. --[[User:SeriousBarbie|SeriousBarbie]] ([[User talk:SeriousBarbie|talk]]) 10:38, 16 September 2015 (EDT)

:Apparently that one got lost when the tag descriptions were moved to a template. The '''S''' means "usable for struct members". —[[User:Wormbo|Wormbo]] 12:53, 16 September 2015 (EDT)

Variables

2015-09-16T16:51:18Z

Wormbo: /* Modifiers */ somehow the struct member tag got lost when moving modifier info to a template

[[wp:Variable#Computer programming|Variables]] are named storage slots for pieces of data. All [[UnrealScript]] variables are [[wp:static typing|staticly-typed]], that means you can only store a specific type of data in them and the type of data is defined in the variable [[wp:declaration (computer science)|declaration]].

There are three basic types of variables in UnrealScript:
* Class variables, which can only be declared at the [[class]] [[wp:Scope (programming)|scope]], before any function, operator, delegate or [[state]] declaration.
* Struct members, which are declared inside their [[struct]]'s declaration block.
* Local variables, which can be declared at the start of [[function]], [[state]], [[operator]] and [[delegate]] bodies before any code statements. (For readability's sake, this article will imply operators and delegates when it mentions functions, unless otherwise noted.)

==Declaration==
A simple class or struct member variable declaration looks like this:
'''var''' ''[[#Modifiers|[modifiers]]]'' [[type]] variablename''''';'''
The ''variablename'' can be any combination of the letters A-Z (case-insensitive), the digits 0-9 and the underscore character _ with two restrictions:
* The name may not start with a digit.
* The name must be shorter than 64 characters.
The ''type'' can not only be a type specification, but also a [[struct]] or [[enum]] declaration.

You can declare multiple variables of the same type in one declaration:
'''var''' ''[[#Modifiers|[modifiers]]]'' [[type]] variablename1''',''' variablename2''',''' ...''';'''
Each of the variable names may optionally have an array size specification to create a [[static array]]:
variablename'''['''arraysize''']'''
You can mix static arrays and non-array variables in a single declaration. The array size only applies to the variable you appended it to.

===Editable variables===
To make the variable accessible from within [[UnrealEd]]'s property windows, use the following syntax:
'''var('''''[groupname[,subgroup3]]''''')''' ''[[#Modifiers|[modifiers]]]'' [[type]] variablename''';'''
The ''groupname'' must be an identifier if specified. If omitted, the class name is used as group name. For struct members, the group name has no effect.

===Local variables===
Local variable declarations in [[function]] bodies are similar, but a bit simpler:
'''local''' [[type]] variablename''';'''
Local variables must be declared at the very top of the function body, between the <code>{</code> and the first line of "executable" code.

You can declare static arrays and multiple variables of the same type as described for class and struct variables above. The ''type'' must be an existing type. It is not allowed to declare new structs or enums here.

After declaration, a local variable is initially null, which can mean different things, depending on the variable type. (Zero for numeric types, False, empty string or array, None, etc.)

'''Note''': As of UDK 2011-06+?{{confirm}} it is also possible to declare local variables in [[state]]s. Local variables must be declared before [[ignores]].

==Modifiers==
For class and struct variables you are allowed to specify one or more variable modifiers. These change the way the variable works in certain situations.
{{Infobox EngineVersion|modifier}}
Modifiers tagged with '''S''' can be used for struct members.

===Inner type modifiers===
You can also specify variable modifiers for the inner type of a [[dynamic array]] declaration. This compiler feature is available in all engine versions, but doesn't have any effect before [[Unreal Engine 3]]. The only currently known instances of this are several variables in two classes of the [[UDK]]'s Engine package ([[UE3:NxForceField (UDK)|NxForceField]] and [[UE3:NxGenericForceFieldBrush (UDK)|NxGenericForceFieldBrush]], both using <code>[[array]]<const native transient [[pointer]]></code>), so this feature might only work at all in newer versions of Unreal Engine 3. '''Note''': All inner modifiers are as well implicity added to the variable modifiers, so for example if you were to add [[EditConst]] the actual variable would as well act upon [[EditConst]].

===Access modifiers===
The following modifiers only apply to class variables and specify, which other classes are allowed to access the variable. The access rules are enforced by the compiler.
; ConstS: Prevents any changes to this variable from within UnrealScript. You are still allowed to specify a value in the [[defaultproperties]] block and access the variable's value in your code. This property is mostly used to protect variables with a special meaning to native code. Classes with '''const''' variables usually have a corresponding setter function for each variable. With bytecode level hacking, it's possible to assign a value to a const variable, but in general, the effect is undefined (ranging from giving the result you want to crashing the game).
; Deprecated2,3: Signals that this variable should no longer be used. Accessing deprecated variables will throw a compiler warning. [[Unreal Engine 3]] will load the value of a '''deprecated''' variable, but ignore it during save.
; PrivateS,2,3: Private variables can only be accessed from within the class they were declared in. Other classes, even subclasses, can't access them.
; PrivateWrite3-x2: Related to the '''private''' access modifier. Causes the variable to be treated as private for writing, but public for reading.
; ProtectedS,2,3: Access to protected variables is only allowed from within the same class and its subclasses. Sibling classes, parent classes and other, unrelated classes can't "see" protected variables.
; ProtectedWrite3-x2: Related to the '''protected''' access modifier. Causes the variable to be treated as protected for writing, but public for reading.
; PublicS,2,3: The default access rule. If no other access rule is specified, this is one is implied. Public variables can be accessed from any other class. Usually you will see this modifier in Unreal Engine 3, along with a native code snippet. One of the most common examples is <code>public{private}</code>, which means the variable is declared as public for UnrealScript, but as private for native code.

===Modifiers affecting values===
These modifiers affect the default value of the variable in some way.

; AutomatedUT2004: Only meaningful for object variables in [[UE2:GUIMultiComponent (UT2004)|GUIMultiComponent]] classes. Indicates that any [[UE2:GUIComponent (UT2004)|GUIComponent]] object(s) referenced by this variable should automatically be added to the [[UE2:GUIMultiComponent_(UT2004)#Controls|Controls]] array. Also works for [[static array|static]] and [[dynamic arrays]]. Objects that aren't GUIComponents are ignored.
::''Implies'': '''noexport''', '''editinline''', '''editinlineuse''' and '''editinlinenotify''', and FYI: any object variable(even parameters and locals) referencing GUIComponents implies '''export''' and '''editinline'''.
; ConfigS: Makes the variable configurable. The default variable value is read from an [[Legacy:INI_File|INI file]] when the class is loaded. Each subclass has its own version of the variable value in its INI file section. If the class is declared with the [[PerObjectConfig]] modifier, the initial instance value of the variable is read from a separate INI section for that object instance.
; DataBinding3: The variable can be manipulated by [[Unreal Engine 3]]'s data store system.
; DuplicateTransient3: Similar to '''transient''' (see below) but applies to object duplication.
; GlobalConfigS: Similar to the '''config''' modifier, but a '''globalconfig''' variable's default value is always read from the INI section of its declaring class, even for subclasses.
::''Implies'': '''config'''
; Input: Attaches the variable to the input system. This is only meaningful for float and byte variables, which can be tied to axis and button input respectively. Input variables are only filled for the local player actor.
; Instanced3: Only meaningful for reference variables. Subobjects assigned to instanced variables are duplicated when an instance of the class is created.
::''Implies'': '''export''' and '''editinline''' even on non-reference variables.
; LocalizedS: Makes the variable localizable. The default value of the variable is read from a [[localization file]] when the class is loaded. Each subclass can have its own localized versions of the variable value. In [[Unreal Engine 1]] and [[Unreal Engine 2|2]] and if the class is declared as [[PerObjectLocalized]] in [[Unreal Engine 3]], each instance of the class can have its own set of localized variable values. This is useful for actors placed in a map.
::''Implies'': '''const'''3
; TransientS: The variables is set to its null value when initializing object instances. The variable's value is never saved to disk in any way.
; Travel1,2: For single player gametypes where a player advances from one map to the next, carrying over all inventory items. Instance variables marked as '''travel''' will keep their value across the map change. Only has an effect for the PlayerPawn in UE1 (or the PlayerController and its Pawn in UE2) and its Inventory chain.

===Modifiers affecting UnrealEd===
These modifiers have some kind of effect in [[UnrealEd]], usually in the actor properties window.

; EdFindableS,2: Adds a 'Find' button to the variable in the property window, which can be used to select an actor from the UnrealEd viewports. For obvious reasons this only makes sense for variables of type Actor or any of its subclasses.
; EditConstS: The variable is read-only in the property window.
; EditConstArrayS,2, editfixedsizeS,3: For dynamic arrays, removes the buttons from the properties window that would change the array length.
; EditHIdeS,3+: Hide in [[UnrealEd]] property lists.{{confirm}}
; EditInlineS,2,3: Only meaningful for object variables. Displays the referenced object's properties as a subgroup below the variable in the property window. If the variable has the value None, a drop-down list of allowed ([[editinlinenew]], non-[[abstract]]) classes can be used to create a new object which is assigned to this variable.
; EditInlineUseS,2,3: Same as '''editinline''', but also adds a 'Use' button to the variable to apply the object selected in the relevant browser for this type of object. Note that the 'Use' button is always available in [[Unreal Engine 3]].
; EditorOnly3+: The variable value is only loaded for [[UnrealEd]].
; EditorTextBoxS?,3+: Replaces the usual input box with a button for opening a separate dialog with a multi-line text box for entering. Probably only useful for [[string]] variables.
; Interp3: The variable can be manipulated by [[Unreal Engine 3]]'s [[Matinee]] system. Only really meaningful for float and vector variables.
; NoClearS,3: Instructs the editor to prevent the user from setting this variable to None. Only really meaningful for object variables.
; NoImportS,3: The variable's value will not be imported from text representation, i.e. when importing from a [[T3D file]] or pasting from clipboard.
; NonTransactionalS,3: The variable is not affected by UnrealEd's undo/redo features.
; SerializeText3+: Variable will not be saved, but will be transfered during copy-paste operations (which are done through text). Works only on native variables.
::''Requirements'': '''Native'''

===Other modifiers===
The following modifiers don't really fit into any of the above categories.
; cacheUT2004: Marks properties of certain classes that should be included in [[UCL file]] entries for that class. This is used e.g. for weapon and mutator names and descriptions.
; editinlinenotifyS,2: Seems to provide special feedback to native code if the variable is edited in a property window. Seems only relevant for native classes and implies '''editinline'''.
; exportS,2,3: For object properties. Objects assigned to this variable are exported as subobjects when exporting class scripts or when exporting actors to [[T3D file]]s or clipboard.
; initS,3: Changes the way string and dynamic array variables are exported to headers for native classes. Default values for this kind of variable are ignored when creating instances of the class.
; native: The variable is loaded and saved in native code. Only valid in native classes.
; noexportS,2,3: Prevents the variable's value from being exported when exporting class scripts or when exporting actors to [[T3D file]]s or clipboard.
; notforconsole3+: The variable value is discarded on console platforms.
; repretry3+: If replication of this variable was not successful the replication will be tried again.
; repnotify3: Can be used on replicated actor variables to instruct the engine to call the [[UE3:Actor events (UT3)#ReplicatedEvent|ReplicatedEvent]] function whenever a value was received for the variable.

===Modifiers with unknown effect===
The effects of these modifiers are not known yet.
; Archetype3: Effect unknown. Used only for the [[UE3:UIPrefabInstance (UT3)#SourcePrefab|UIPrefabInstance.SourcePrefab]] variable in UT3.
; CrossLevelActive3+: See below.
; CrossLevelPassive3+: Probably related to level streaming or multiple levels loaded at the same time.

==Initial values==
The initial values of class variables can be specified in the [[defaultproperties]] block. The initial value can be different in subclasses without affecting the value of parent classes. Some class variables, for example Name, Outer, Tag or Location, are initialized with other values when an instance of the class is created.

Initial values of struct members can be specified in thee [[structdefaultproperties]]. In structs that extend other structs, the initial value can differ from the value in the parent struct. Since structs are data types and only exist as values of other variables, initial member values for those variables may differ from the default struct member value.

The initial value of a local variable is always the null value for the declared variable [[type]]. The initial value for function parameters is the value passed in when the function is called. Omitted optional parameters initially contain the type's null value. In [[Unreal Engine 3]] it is also possible to specify a different initial value for omitted optional parameters.

==Accessing variables==
Class variables can be accessed directly by just specifying their name from instance functions, state code or the [[replication block]] inside the declaring class or any of its subclasses.

The default value for a class variable can be accessed directly by using the keyword '''default''' and the context operator '.' from anywhere inside the class, including static functions:
'''default.'''variablename
The default value of another class can be accessed by providing a different class context to the '''default''' keyword:
objectreference'''.default.'''variablename
The object reference can be an [[Literals#Objects|object literal]] or an object reference variable. If the type of the object reference is a Class or a [[class limiter]], that class is used, otherwise the referenced object's class type is used to access the default variable value. When using an object literal is usually doesn't make sense to use a non-class literal because you usually know the class of the referenced object and the engine really doesn't care about the actual object if it is only interested in the class anyway.

Struct member variables and class variables of other classes or other instances of the same class can be accessed with the context operator '.', like in the following example:
<uscript>
function float getX(vector V)
{
return V.X;
}
</uscript>
This accesses the struct member variable ''X'' of the vector value passed to the function as parameter ''V''. The parameter ''V'' is a local variable to the function ''getX''. Local variables can only be accessed inside their containing function.

Variables accessed as described in this section can be used as an [[wp:lvalue|L-value]], i.e. used on the left side of an assignment operator or as an [[out]] parameter in a function call.

{{navbox unrealscript}}

String

2015-08-29T19:51:11Z

Wormbo: replaced redirect with actual information about the string type

UnrealScript has a character string data type called '''string'''. Strings can contain any combination of [[wp:Unicode|Unicode]] characters. Note that the internal representation uses UTF-16 characters. UTF-8 is not recognized by the compiler or any of the built-in string operations.

String values are immutable and UnrealScript neither provides "character" type nor allows direct access to individual string characters. There are, however, functions for extracting substrings and returning the Unicode value of the first character of a string. There's also a function for returning a string of length 1 containing a character corresponding to a specified Unicode value.

Very early builds of [[Unreal Engine 1]] had a fixed-length string type, which was declared with the syntax <code>string[''length'']</code>. This type is no longer supported and only mentioned here in case you run into its declaration in old code snippets.

In [[Unreal Engine 2]] (or at least [[UT2004]]) there also is an undocumented type called '''button''' that is an alias for the standard string type, but implies the [[Cache]] variable modifier. It is not actually used in stock code and there's no reason for you to ever declare a variable with the ''cache'' modifier, so this is purely informative.

==Literals==
String literals start and end with double quotes. Between these there may be any number of characters, except line breaks or the null character. 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> (the empty string and default string value)

Technically string literals are allowed to have a length of up to 1023 characters. String values generated at runtime may be longer. Internally strings are zero-terminated, which means no string can contain the null character because it would be recognized as the end of the string.

==String operators==
The following [[operators]] are commonly declared in the {{classgames|Object}} class and thus are available globally:

;<code>==</code>:Case-sensitive equality comparison. Returns ''true'' [[wp:iff|iff]] the string expression on the left and right are identical.
;<code>~=</code>:Case-insensitive equality comparison. Returns ''true'' iff the string expression on the left and right are identical, ignoring any differences in the case of the letters A-Z. Note that non-ASCII characters will be matched case-sensitively, i.e. <code>"a" ~= "A"</code> is ''true'', but <code>"Ä" ~= "ä"</code> is ''false''.
;<code><</code>:Case-sensitive lexicographical comparison. Returns ''true'' iff the string expression on the left comes lexicographically before the string expression on the right.
;<code>></code>:Case-sensitive lexicographical comparison. Returns ''true'' iff the string expression on the left comes lexicographically after the string expression on the right.
;<code><=</code>:Case-sensitive lexicographical comparison. Returns ''false'' iff the string expression on the left comes lexicographically after the string expression on the right.
;<code>>=</code>:Case-sensitive lexicographical comparison. Returns ''false'' iff the string expression on the left comes lexicographically before the string expression on the right.
;<code>!=</code>:Case-sensitive inequality comparison. Returns ''false'' iff the string expression on the left and right are identical.
;<code>$</code>:String concatenation. <code>"abc" $ "def"</code> evaluates to the value <code>"abcdef"</code> at runtime. Note that the UnrealScript compiler will not optimize this kind of expression. This operator will "[[coerce]]" (i.e. automatically typecast) its operands to type string.
;<code>@</code>:Spaced string concatenation. The expression <code>a @ b</code> essentially corresponds to <code>a $ " " $ b</code>, except that it is slightly more efficient. Still you may want to limit its use to concatinating two non-literal expressions, as <code>"abc " $ d</code> is slightly more efficient than <code>"abc" @ d</code>. This operator will "coerce" (i.e. automatically typecast) its operands to type string.
;<code>$=</code>2+:Combined concatenation and assignment. Left operand must be an assignable expression, i.e. a variable, struct member or array element. This operator will "coerce" (i.e. automatically typecast) the right operand to type string.
;<code>@=</code>2+:Combined spaced concatenation and assignment. Left operand must be an assignable expression, i.e. a variable, struct member or array element. Like for the <code>@</code> operator, <code>foo $= " bar"</code> is slightly more efficient than <code>foo @= "bar"</code>. This operator will "coerce" (i.e. automatically typecast) the right operand to type string.
;<code>-=</code>2+:Substring removal. This operator will remove all substrings from the variable, struct member or array element on the left side that match the string expression on the right side case-sensitively. <code>foo -= "an"</code> will turn the string "Banana Ananas" into "Ba Anas". This operator will "coerce" (i.e. automatically typecast) the right operand to type string. Note that there is no operator <code>-</code> for strings. <code>a -= b;</code> is essentially the same as <code>a = Repl(a, b, "", False);</code>.
;<code>=</code>: The build in assignment operator. Assigns the string value of the right side operand to the variable, struct member or array element represented by the left operand. Note that this operator does ''not'' "coerce" any operands and unlike the combined operators also does not return any value.

==Global string functions==
The following [[static functions|static]] string functions are commonly declared in the {{classgames|Object}} class and thus are available globally:

;<code>int Len(coerce string S)</code>:Returns the number of characters in the specified string value.
;<code>int InStr(coerce string S, coerce string T)</code>:Locates the first case-sensitive match of ''T'' in ''S'' and returns its zero-based start position. Returns -1 if ''T'' cannot be found in ''S''.
;<code>string Mid(coerce string S, int start, optional int length)</code>:Returns the substring of ''S'' starting at position ''start'', including up to ''length'' characters. If ''length'' is omitted, all characters up to the end of the string are returned.
;<code>string Left(coerce string S, int i)</code>:Returns the first ''i'' (i.e. left-most) characters from ''S''.
;<code>string Right(coerce string S, int i)</code>:Returns the last ''i'' (i.e. right-most) characters from ''S''.
;<code>string Caps(coerce string S)</code>:Returns ''S'' with all lowercase ASCII letters (a-z) converted to their uppercase forms (A-Z).
;<code>string Locs(coerce string S)</code>2+:Returns ''S'' with all uppercase ASCII letters (A-Z) converted to their lowercase forms (a-z).
;<code>string Chr(int i)</code>:Returns a string of length 1 containing the Unicode character with the specified character code. Note that the empty string will be returned when specifying 0 as code.
;<code>int Asc(string S)</code>:Returns the Unicode character code of the first character in ''S''. This function will return 0 for the empty string. Note that unlike most other global string function, ''Asc'' does not "[[coerce]]" (auto-convert) its parameter to type string.
;<code>string Repl(coerce string Src, coerce string Match, coerce string With, optional bool bCaseSensitive)</code>2+:Replaces every occurrence of ''Match'' in ''Src'' with ''With'' using case-sensitive or case-insensitive (this is the default) matching.

{{navbox unrealscript}}

Template:Navbox unrealscript

2015-08-29T18:33:56Z

Wormbo: modified simple type links to let them point to dedicated simple type pages, in case we ever have more than just redirects; FilterEditorOnly is not a flow control statement

{{navbox
| name = navbox unrealscript
| title = [[UnrealScript reference]]

| group1 = Declarations
| list1 = [[Preprocessor]] • [[Classes]] • [[Interfaces]] • [[Cpptext]] • [[Constants]] • [[Enums]] • [[Structs]] • [[Variables]] ([[Metadata]]) • [[Replication block]] • [[Operators]] • [[Delegates]] • [[Functions]] • [[States]] • [[Defaultproperties]] ([[Subobjects]])

| group2 = [[Types]]
| list2 = [[bool]] • [[byte]] • [[float]] • [[int]] • [[name]] • [[string]] • [[Types#Reference types|Object]] • [[Class_limiter#Class|Class]] • [[Enums]] • [[Structs]] ([[Vector]] ⋅ [[Rotator]] ⋅ [[Quat]] ⋅ [[Color]]) • [[Static arrays]] • [[Dynamic arrays]] • [[Delegates]] • [[Typecasting]]

| group3 = [[Literals]]
| list3 = [[Literals#Boolean values|Boolean]] • [[Literals#Float numbers|Float]] • [[Literals#Integer numbers|Integer]] • [[Literals#Names|Names]] • [[Literals#Objects|Objects]] ([[None]] ⋅ [[Self]]) • [[Literals#Vectors|Vectors]] • [[Literals#Rotators|Rotators]] • [[Literals#Strings|Strings]]

| group4 = [[Flow control|Flow]]
| list4 = [[GoTo statement|GoTo]] • [[If statement|If]] • [[Assert statement|Assert]] • [[Return statement|Return]] • [[Stop statement|Stop]] • [[Switch statement|Switch]] • [[While loop|While]] • [[Do...Until loop|Do...Until]] • [[For loop|For]] • [[ForEach loop|ForEach]] • [[Break statement|Break]] • [[Continue statement|Continue]]

| group5 = [[Specifiers]]
| list5 = [[Function call specifiers#Super|Super]] • [[Function call specifiers#Global|Global]] • [[Functions#Syntax 3|Static]] • [[Variables#Accessing variables|Default]] • [[Constants#Usage|Const]]

| group6 = [[UnrealScript]]
| list6 = [[UnrealScript syntax|Syntax]] • [[UC File|.UC]] • [[UCI File|.UCI]] • [[UPKG File|.UPKG]] • [[Comments]] • [[Compiler directives|#directives]] • [[Native coding|Native]]
}}<includeonly>
{{#ifeq:{{#sub:{{PAGENAME}}|0|12}}|UnrealScript|[[Category:UnrealScript reference| {{PAGENAME}}]]|[[Category:UnrealScript reference|{{PAGENAME}}]]}}
</includeonly><noinclude>
{{documentation}}
</noinclude>

Talk:Types

2015-08-29T18:22:13Z

Wormbo: /* hint to concatenate strings */

==Strings and replication==
I have just done some testing in UT2004 (ie Unreal Engine 2.5) concerning Strings and replication. My test included a server to client replicated string variable I filled on the server in PostBeginPlay and replicated (reliably) if bNetInitial. I output its length client-side in PostNetBeginPlay and each Tick.

Strings longer than 390 characters took one Tick before they were replicated completely, ie at PostNetBeginPlay, the client-side length was still zero, in the first Tick it had the correct length.

Strings longer than 496 characters did not get replicated at all, not even truncated. The client-side length remained zero.

If anybody can confirm or clarify this, this might be useful information in the String section.

--[[User:Pd|Pd]] 06:36, 5 May 2011 (UTC)
:Strings with a length greater than 255 can not be replicated. --[[User:Eliot|Eliot]] 10:19, 5 May 2011 (UTC)
::I expected something like that, but string up to 384 to 390 worked very well for me, so that can't really be true. Or is that just the official statement (similar to ''UE3 doesn't support dynamic bool arrays'' while in fact it does)? --[[User:Pd|Pd]] 16:05, 5 May 2011 (UTC)

:The reason for the observed behavior is that any replicated variable (especially long strings and large structs) must fit into a single packet in order to be replicated. UE does not split replication bunches across packets. Either it fits or it won't replicate. The delay for the 390 chars string is caused by the string not fitting into the initial packet along with the other replicated data. It is replicated later in a separate packet. That 496 chars string not being replicated at all is caused by the same issue: The string won't even fit in a packet if nothing else is added to it. The maximum packet size depends on [[wp:Maximum transmission unit|MTU]] settings along the route from your computer to the game server. The maximum Ethernet MTU is 1500, but IPv4 typically operates on 576. That's the raw payload size of the IP packet, i.e. UDP header, UE networking header data and the actual replicated variable value need to fit into that. Note that there's actually no built-in size limit for replicated values in the Unreal Engine. If MTU is large enough, you could even replicate 1k char strings —[[User:Wormbo|Wormbo]] 16:40, 5 May 2011 (UTC)

== hint to concatenate strings ==
Of course there may be more possibilities to concatenate strings than '@', but please allow then a link to a page where handling of strings is described. I was searching for the name of this operator (I know similar from other programming languages) and started my search of course with "string". So at least a link to string operations would be useful there. --[[User:SeriousBarbie|SeriousBarbie]] ([[User talk:SeriousBarbie|talk]]) 11:13, 29 August 2015 (EDT)

Well, there is a dedicated [[Operators]] page, and it is linked in the navigation box at the bottom of every UnrealScript reference page. However, I agree that searching for "string" or "string operators" should bring up more results than just the short string type description. —[[User:Wormbo|Wormbo]] 14:22, 29 August 2015 (EDT)

Types

2015-08-29T05:57:36Z

Wormbo: Undo revision 46196 by SeriousBarbie (talk) there's more than just @ to concatinate strings, but this page isn't for operators

[[UnrealScript]] is a strongly-typed language and has various built-in data types. UnrealScript types can be divided in three general groups: primitive types, reference types and composite types.

==Primitive types==
A primitive type only consists of a single and usually simple value. Variables declared of a primitive type directly contain that value and when assigning that value to another variable or passing it to a function call, a new copy of the value is created. Modifications to that copy have absolutely no effect on the original value still stored in the source variable.

===Int===
UnrealScript has two integer types and '''int''' is the larger of them. Int values are integer numbers in the range -2147483648 to 2147483647, in other words signed 32 bit values.

[[Literals#Integer numbers|Int literals]] can be specified in decimal or hexadecimal notation. Values exceeding the allowed range are truncated to the least significant 32 bits. For example the hexadecimal literal 0x100000005 actually represents the value 5.

===Byte===
The smaller of UnrealScript's two integer types is '''byte'''. Byte values are integer numbers in the range 0 to 255, in other words unsigned 8 bit values.

Any [[Literals#Integer numbers|int literal]] can also be used in "byte context". If the value is outside the allowed range it will be truncated to the 8 least significant bits. For example the hexadecimal literal 0x100 (256) actually represents the value 0 and the decimal literal -1 represents the value 255.

===Bool===
UnrealScript's [[wp:boolean|boolean]] type is '''bool''' and allows the values ''true'' and ''false''. These are also the names of the [[Literals#Boolean values|boolean literals]].

The bool type has some restrictions in UnrealScript. For example it's not possible to declare [[#Static array|static]] or [[#Dynamic array|dynamic arrays]] of bool values in [[Unreal Engine]] generations 1 and 2 or to use the parameter modifier "out" on bool parameters in [[function declaration]]s. Starting with Unreal Engine 3 dynamic arrays of bool are supported, even though the [[udn3:UnrealScriptReference|UnrealScript reference on UDN]] disagrees.

===Float===
UnrealScript has a [[wp:single precision|single precision]] [[wp:floating point|floating point]] type called '''float'''. The possible float values are distributed over the huge range of about 3.403·1038 to -3.403·1038. The smallest possible value greater than 0 is about 1.175·10-38. Generally, float values have a precision of about 6 or 7 decimal digits.

[[Literals#Float numbers|Float literals]] can either be specified in decimal or scientific notation. For example the literal 1.2e3 means 1.2·103 = 1200. Note that float literals must always contain the decimal point, even when using scientific notation, and must always start with a number or with the minus sign followed by a number. Unfortunately, negative exponents are not allowed in scientific notation. A hexadecimal representation like in Java is not supported.

If a floating point operation has a result that exceeds the highest or lowest possible number, the return value has the special value of positive or negative infinity respectively. Invalid operations such as division by zero or adding positive and negative infinity return the special value ''NaN'', "Not a Number". Be careful about those three special values as they will propagate. That means, if you subtract, add, multiply or divide infinity values, the result will be infinity again. If you perform an operation with the ''NaN'' value, the result will either be ''NaN'' again or (for comparison operators) something totally unexpected. For example if you perform the operation <code>a = x / 0</code>, variable a will contain ''NaN''. Now the comparison <code>a == a</code> will actually return the value ''false''! Unlike ''NaN'', infinity values will behave as expected if used in comparison operations, that is positive infinity is greater than any other value, negative infinity is smaller than any other value.

''Technical information:'' As specified in the [[wp:IEEE floating-point standard|IEEE floating-point standard]], the float type internally has a length of 32 bits and consists of a 23 bit fraction part, an 8 bit exponent and one sign bit. Especially the 23 bit fraction part (called the "mantissa") imposes a limit on floating point precision. When large int values greater than 223 or smaller than -223 are [[typecast]]ed to float, they may get rounded.

===String===
UnrealScript has a character string data type called '''string'''. Strings can contain any combination of [[wp:Unicode|Unicode]] characters.

[[Literals#Strings|String literals]] are enclosed in double quotes and may not extends past the end of a line. Technically string literals (but not values) are allowed to have a length of up to 1023 characters. Internally strings are zero-terminated, which means no string can contain the null character because it would be recognized as the end of the string.

String values are immutable and UnrealScript neither provides "character" type nor allows direct access to individual string characters. There are, however, functions for extracting substrings and returning the Unicode value of the first character of a string. There's also a function for returning a string of length 1 containing a character corresponding to a specified Unicode value.

Very early builds of [[Unreal Engine 1]] had a fixed-length string type, which was declared with the syntax <code>string[''length'']</code>. This type is no longer supported and only mentioned here in case you run into its declaration in old code snippets.

In [[Unreal Engine 2]] (or at least [[UT2004]]) there also is an undocumented type called '''button''' that is an alias for the standard string type, but implies the [[Cache]] variable modifier. It is not actually used in stock code and there's no reason for you to ever declare a variable with the ''cache'' modifier, so this is purely informative.

===Name===
The data type '''name''' is a very unusual one. To the programmer it appears a lot like a case-insensitive string with very limited character set. Every object and every class has a name, but names are also used for a variety of other things, such as identifying [[states]], code [[labels]], trigger events or bones of a [[skeletal mesh]].

[[Literals#Names|Name literals]] are enclosed in single quotes and may contain the letters A to Z, both upper and lowercase, the numbers 0 to 9, the underscore character _, the hyphen character -, and the space character. This could be represented in [[wp:regular expression|regex]] as <code>([a-zA-Z0-9_\- ]*)</code>. Names are limited to a length of up to 63 characters.

Internally names are represented as int values, which makes sense since names are used in many places and would take up a lot of space if represented as strings. At runtime, the first mentioned string representation of a name is stored in the global name table. Whenever a name value is to a string through [[typecasting]], the string representation from the name table is used. This means that even though you could use the name literal <code>'cOnTrOlLeR'</code> in your code, it would most likely be represented by the string <code>Controller</code> instead, because that's the spelling used for the name of the class with that name.

Newer builds of the [[Unreal Engine 3]] provides an additional way for specifying values of type name via the '''NameOf'''() pseudo-function. Similar to the [[ArrayCount]]() pseudo-function, NameOf() is replaced with a name constant by the compiler. The parameter for NameOf() is either a variable or function name for use in ReplicatedEvent() or with the various Timer management functions.

===Enum===
{{main|Enums}}
An '''enum''' type is a named list of identifiers that act as [[Literals#Enums|literals]] for the values of the enum type. UnrealScript's enumerated types are a bit like "glorified integer values", similar to C++ enumerations. The first value of an enum type corresponds to 0, the second value to 1, and so on.

==Reference types==
Unlike [[variables]] of primitive types, variables declared as a reference type only contain a [[wp:reference (computer science)|reference]] to the actual data. When assigning a reference type value to a variable or passing it to function calls, only the reference, not the referenced data, is copied. As a result it is possible that two reference type variables point to the same data and changes made to the data through one variable are immediately visible through the other.

===Object===
An object reference does not contain an object, it only points to (i.e. "reference") an instance of an object. That means the object reference's value actually is a pointer, not an object. Different object references may point to the same object. An object reference may also point to no object at all.

Object references can be restricted to instances of a certain class. For example, an object reference might only accept instances of the class WebApplication, which also includes instances of WebApplication subclasses like UTServerAdmin.

[[Literals#Objects|Object literals]] start with the name of the object's class, followed by the qualified or unqualified name of the object instance to reference, enclosed in single quotes. It is also possible to specify a literal for the empty object reference with the keyword <code>None</code>. Another special object literal is the keyword <code>Self</code>, which references the object instance executing the current function or state code. It is not available in [[static functions]], because those functions are not executed in the context of an object instance but of an object class.

===Actor===
Actor references are basically the same as object references, just restricted to Actor or one of its subclasses. The only difference to non-actor references is, that the Actor class provides a ''Destroy'' method. This method not only gets rid of the actor instance it was called on, but also implicitly sets all references to that actor instance to ''none''.

Most of your object references will probably be actor references, but apart from ''None'' and ''Self'' you will rarely encounter object literals of type Actor or one of its subclasses. In fact, Actor-type object literals are forbidden in UnrealScript code prior to [[Unreal Engine 3]]. Mappers sometimes see actor literals in the property window of various level objects, but UnrealScript programmers usually won't use them. Most actor literals in Unreal Engine 3 source code are [[archetypes]] in exported [[defaultproperties]] blocks.

===Interface===
{{main|Interfaces}}
Interface references are also object references, but restricted to an interface type. This kind of reference can point to any object instance of a class [[implements|implementing]] that interface.

===Class===
{{main|Classes}}
A class reference is very similar to an object reference, except that it is restricted to the type Class. Class references can be further restricted to a certain meta class, that means the type of referenced class. Such a restricted class reference is called a '''class limiter''' and is denoted by the keyword <code>Class</code> followed by the name of the meta class in angle brackets. For example <code><nowiki>class<Info></nowiki></code> denotes a reference that can point to the class Info or one of its subclasses.

Class literals are specified in the same way as other object literals. The type of reference, here ''class'', followed by the class name, optionally qualified with the containing package name, and enclosed in single quotes. For example <code>class'Info'</code> or <code>class'Engine.Info'</code> references the Info class located in the Engine package. The special object literal ''None'' can be used for class references and means "no class".

One important restriction of class references is the lack of interface support. Classes implementing a certain interface can be anywhere in the class hierarchy, but class limiters only support direct inheritance. This means, that if you want a reference to classes implementing a certain interface, you need to use a generic class reference or the class limiter <code><nowiki>class<Object></nowiki></code>. A reference of type <code><nowiki>class<Interface></nowiki></code> would only allow references to the interface class itself (or any of its subinterfaces), but not to any class implementing the interface!

===Delegate===
{{main|Delegates}}
Delegates were introduced in Unreal Engine 2 and are '''function references'''. In Unreal Engine 2, delegates could only be declared using function syntax and replacing the keyword ''Function'' with the keyword ''Delegate''. Unreal Engine 3 also provides a notation similar to class limiters or dynamic arrays that can be used as variable or parameter type. This notation starts with the keyword <code>Delegate</code>, followed by the name of a prototype delegate function declaration in angle brackets.

[[Literals#Functions|Function literals]] are only used for delegate assignments and look more like a variable access than a literal. Basically you reference the object instance containing the function you want to assign to a delegate property (unless, of course, the function is contained in the same object instance as the code doing the assignment), followed by a dot and the pure function name without anything afterwards. As with object references, the keyword ''None'' means "no function". For delegate function declarations this means the default body, if available, is executed when the delegate is called.

===Pointer===
Also starting with Unreal Engine 2, UnrealScript has a generic [[wp:Pointer_(computing)|pointer]] data type, but it only serves as a placeholder for pointer variables in [[native code]]. UnrealScript itself provides no way to access or modify pointer properties.

==Composite types==
Unlike all the other types described above, a composite type can contain more than one value. The composite types available in UnrealScript all work similar to primitive types: assigning them to other variables or passing them in function calls creates a copy of the data.

===Struct===
{{main|Structs}}
Structs (or structures) are a composition of a fixed number of values that may have different types. Struct types are no reference types, that means they are stored directly in the variable and copied as a whole when assigned to variables or passed as function parameters or returned as function result. Struct values are always replicated as a unit, but for a few structs like vector or rotator replication is not accurate due to bandwidth optimizations. Struct values may not be allowed for replication if the struct type is too large to fit in one network packet.

Except for [[Literals#Vectors|vectors]] and [[Literals#Rotators|rotators]], there is no way to specify a complete struct value directly in code.

===Static array===
{{main|Static arrays}}
Static arrays are a composition of a fixed number of values with identical type. Static arrays can be passed as a whole as function parameters, though this will cause all values to be copied. They can't be assigned to variables or returned as function results, though. For replication, each element is considered separately. It is not possible to declare a static array of type bool or of a dynamic array type. Static arrays of a struct type containing bools or dynamic arrays are no problem, though. There are no literals for static arrays.

===Dynamic array===
{{main|Dynamic arrays}}
Dynamic arrays are also a composition of multiple values of the same type, but the actual number of values may change over time. Dynamic arrays can be assigned to variables, passed as function parameters and returned as function results, but every time the entire array is copied. They do not support replication at all.

In [[Unreal Engine 1]], dynamic arrays can be declared, but there's no way to access them. Only starting with [[Unreal Engine 3]], dynamic arrays of type bool can be used. (You can declare dynamic bool arrays in Unreal Engine 2, but they don't work.) It is not possible to directly use a dynamic array type in other static or dynamic arrays. It is possible to wrap other arrays or bool variables in a struct type and create a dynamic array of that struct type, though. Function parameters that are dynamic arrays may not be optional. There are no literals for dynamic arrays.

===Multi-dimensional arrays===
{{main|multi-dimensional arrays}}
Multi-dimensional and jagged arrays are not supported in UnrealScript. You can work around that either by using an array of [[structs]] that contain an array or by performing index arithmetics on any kind of one-dimensional array.

===Map===
See [[wp:Associative_array|Associative array]], [[wp:Map_(C%2B%2B)|C++ Map]] and [http://www.google.be/search?q=c%23+dictionary C# Dictionary].

In [[Unreal Engine 1]] and 2 you cannot use this feature yet so says the compiler error (''Error, Map are not supported in UnrealScript yet'').

In [[Unreal Engine 3]] you can declare maps however you cannot access them yet with UnrealScript.

{{navbox unrealscript}}

Network

2015-08-12T16:22:21Z

Wormbo: Redirected page to Replication overview

#REDIRECT [[Replication overview]]

Unreal Wiki:Sandbox

2015-08-09T08:55:04Z

Wormbo:

Do not edit the area above the separator line, please.
----
UIComp_DrawImage custom subclasses:
{{#dpl:
|category=Subclasses of UIComp_DrawImage{{!}}Subclasses of UIComp_DrawImage (UE3)}{{!}}Subclasses of UIComp_DrawImage (UT3)
|category=Custom classes{{!}}Custom UE3-specific classes{{!}}Custom UT3-specific classes
|namespace={{#if:UE3|{{!}}UE3}}{{!}}User
|format=,[[%PAGE%|%TITLE%]],,
|inlinetext=, 
|shownamespace=false
|replaceintitle=/ (?!\()/,_
|resultsheader=\n;Known custom subclasses::
|oneresultheader=\n;Known custom subclass::
|noresultsheader=<nowiki></nowiki>
|allowcachedresults=true
}}

Unreal Wiki:Sandbox

2015-08-09T08:54:27Z

Wormbo: testing DPL with many categories

Do not edit the area above the separator line, please.
----
UIComp_DrawImage custom subclasses:
{{#dpl:
|category=Subclasses of UIComp_DrawImage{{#if:UE3|{{!}}Subclasses of UIComp_DrawImage (UE3)}}{{#if:UT3|{{!}}Subclasses of UIComp_DrawImage (UT3)}}
|category=Custom classes{{#if:UE3|{{!}}Custom UE3-specific classes}}{{#if:UT3|{{!}}Custom UT3-specific classes}}
|namespace={{#if:UE3|{{!}}UE3}}{{!}}User
|format=,[[%PAGE%|%TITLE%]],,
|inlinetext=, 
|shownamespace=false
|replaceintitle=/ (?!\()/,_
|resultsheader=\n;Known custom subclasses::
|oneresultheader=\n;Known custom subclass::
|noresultsheader=<nowiki></nowiki>
|allowcachedresults=true
}}

Unreal Wiki:Community portal

2015-08-09T08:40:02Z

Wormbo: Wormbo moved page Unreal Wiki:Community Portal to Unreal Wiki:Community portal

Welcome to the '''{{SITENAME}} Community Portal'''. This is the place to find out what's happening on Unreal Wiki and what you can do to help.
__NOTOC__
{| cellpadding="0" cellspacing="10px" style="width:100%;"
| id="topic-list" style="vertical-align:top;" |
== News ==
===Starting UDK documentation===
Epic's [[Unreal Development Kit]] is here! The Unreal Wiki needs your contributions to document the new features provided by the latest Unreal Engine 3 release. [[:Category:UDK-specific classes|Class description pages]] have already been generated, but many of them still need documentation. The [[UE3:Unreal Editor|UDK Editor]] doecumentation is not up to date, or even complete. We do have a list of [[external UDK tutorials]], though.

As you can see, there's still a lot to do, so let's get started. See the [[#Help out|Help out]] section below to find out how you can help and what specifically needs to be done.

===Unreal Wiki reloaded===
As you may have noticed, '''{{SITENAME}}''' has migrated from the old [[wp:UseModWiki|UseModWiki]] software to a recent version of [[wp:MediaWiki|MediaWiki]].

Currently we are in the process of getting (re-)started with content. Pages and images have been imported from the [[Legacy:Home_Page|old Unreal Wiki]] and can be browsed as before. Old links via <code><nowiki>/wiki/Page_Name</nowiki></code> now redirect to <code><nowiki>/Legacy:Page_Name</nowiki></code> for normal pages or <code><nowiki>/Category:Legacy_Page_Name</nowiki></code> for categories and category-like pages. We've made best effort to compensate the different ways UseModWiki and MediaWiki normalize page names, so external links should not be broken. If you still find such a link, please tell the external site's admin to link to the new page instead.

As part of the restart, we want to create a better topic structure for the old and new knowledge to be documented. See the [[#Help out|Help out]] section below to find out how you can help in this process.

== General ==
What is the Unreal Wiki and how can you use it?
* [[Unreal Wiki:About|About the Unreal Wiki]]
* [[Unreal Wiki:Getting started|How to get started]]

=== Help out ===
Unreal Wiki is seeking to provide comprehensive documentation about the [[Unreal Editor]] and [[Unreal Engine]] games as well as tutorials for creating content for them. You can help out in a number of ways, for example by writing tutorials, documenting engine features and, most importantly, improve existing documentation.
* [[Unreal Wiki:Helping out|How do I help?]]
* [[Unreal Wiki:Task list|What needs to be done?]]

=== Need help? ===
If you have questions about Unreal Wiki that these pages do not answer, feel free to use an [[wikipedia:IRC Client|IRC Client]] to join our channel [irc://irc.enterthegame.com/unrealwiki #unrealwiki] on the EnterTheGame network. Or just browse over to the [http://forums.beyondunreal.com/forumdisplay.php?forumid=249 Unreal Wiki forum] at the BeyondUnreal Forums.
| style="vertical-align:top;" |
{| class="infobox infobox-pages" id="recent-edits" style="width:300px;float:none;margin-left:auto;"
|-
| style="text-align:center;font-size:smaller;" |''See [[Special:Recentchanges|Recent changes]] for all changes.''
|-
! Recently updated user pages
|-
|<dpl>
namespace=User
count=5
ordermethod=lastedit
order=descending
mode=userformat
adduser=true
addeditdate=true
userdateformat=g:ia D, M j
format=<ul>,<li>[[%PAGE%|%TITLE%]] %USER% - %DATE%,</li>,</ul>
noresultsheader=''None''
</dpl>
|-
! Recent user talk
|-
|<dpl>
namespace=User_talk
count=5
ordermethod=lastedit
order=descending
mode=userformat
adduser=true
addeditdate=true
userdateformat=g:ia D, M j
format=<ul>,<li>[[%PAGE%|%TITLE%]] %USER% - %DATE%,</li>,</ul>
noresultsheader=''None''
</dpl>
|}
|}

Unreal Wiki talk:Community portal

2015-08-09T08:40:02Z

Wormbo: Wormbo moved page Unreal Wiki talk:Community Portal to Unreal Wiki talk:Community portal

Wow! No main discussion page yet! Hope you all don't mind this comment. Never been on a wiki before. --EscapingTheSilence

:Most of the discussion is happening on [[Talk:Main Page]]. -[[User:Wormbo|Wormbo]] 11:34, 11 April 2008 (UTC)

I'm not sure I see the vision for this page. Is it to be a portal to other closely-related sites? Perhaps links to modding community sites? Or will it just be a depository for recent {{SITENAME}} news and links for new recruits? -[[User:DalinSeivewright|DalinSeivewright]] 03:59, 18 April 2008 (UTC)

It seems to be the new [[Legacy:UnrealWiki_To_Do]]++. —''[[User:Graphik|Graphik]] 04:20, 18 April 2008 (UTC)''

Well if thats the case then [[Unreal_Wiki:Task_list]] is wasted :P The Community Portal should be centered around budding developers (i.e. links to developer journals, etc.) and general wiki user (i.e. featured user, etc.). -[[User:DalinSeivewright|DalinSeivewright]] 05:42, 22 April 2008 (UTC)

Unreal Wiki:Community Portal

2015-08-09T08:40:02Z

Wormbo: Wormbo moved page Unreal Wiki:Community Portal to Unreal Wiki:Community portal

#REDIRECT [[Unreal Wiki:Community portal]]

Unreal Wiki talk:Community Portal

2015-08-09T08:40:02Z

Wormbo: Wormbo moved page Unreal Wiki talk:Community Portal to Unreal Wiki talk:Community portal

#REDIRECT [[Unreal Wiki talk:Community portal]]

Legacy talk:Trigger

2014-09-04T22:36:09Z

Wormbo: /* Message Length */ that's probably a replication limit

== Message Length ==
The length of the message string is limited at least in UT99. I found that longer strings (~650 chars) are displayed if playing a map locally, but not if played on server. With server version 451 strings longer than 496 chars are not displayed. --[[User:SeriousBarbie|SeriousBarbie]] 21:11, 4 September 2014 (UTC)

:That's probably due to replication limits. The trigger message originates on the server, where the triggering happens, and is sent over the network. But for that, it will have to fit into a single network packet, which limits the possible string length. Then again, I wonder what kind of text walls you're trying to show. ;-) —[[User:Wormbo|Wormbo]] 22:36, 4 September 2014 (UTC)

Talk:Key Bindings (UT2004)

2014-08-01T20:06:31Z

Wormbo: Created page with 'What's the purpose of this page? It's an orphan and its information doesn't quite look like it'd be useful for editing directly. On the UnrealWiki you'd probably expect a DefUser…'

What's the purpose of this page? It's an orphan and its information doesn't quite look like it'd be useful for editing directly. On the UnrealWiki you'd probably expect a DefUser.ini dump instead, while the pretty-colored textual representation is more a thing for Liandri Archives. —[[User:Wormbo|Wormbo]] 20:06, 1 August 2014 (UTC)

Legacy talk:Movement Metrics (UT2004)

2014-06-25T15:45:23Z

Wormbo: nope, but nobody asked before

Cool page, have you ever put the statistics program to work in other forms of the editor, this would really come in handy for my level editing in the Red Orchestra 2 version of the UDK. Yours Truly [[User:UnrealMuskrat|UnrealMuskrat]] 19:54, 22 June 2014 (UTC)

:Well, write a tool to collect these stats (or port the one linked for UT2004) and go collect them. ;-) —[[User:Wormbo|Wormbo]] 15:45, 25 June 2014 (UTC)

Legacy:Movement Metrics (UT2004)

2014-06-22T05:38:04Z

Wormbo: /* Abbreviations */ clarified "Double Jump"

Distances that the player in [[Legacy:UT2004|UT2004]] can jump or dodge. All units are [[Legacy:UU|UU]].

Many of these have been determined with the help of the Jump Stats feature in [http://www.koehler-homepage.de/Wormbo/unrealwiki.html#MD Multi Dodging 2k4 v3] (written by [[Legacy:Wormbo|Wormbo]]), which displays statistics about the distances heights and speeds gained during gameplay. (Make sure you disable everything but the "Gather movement stats" option.)

==Abbreviations==
;J : Jump from the ground
;D : Dodge from the ground
;DJ : Double Jump (just the mid-air jump that can be performed at the apex of a jump or dodge)
;WD : Wall Dodge
;IJ : Impact Jump
;ID : Impact Dodge (like Impact Jump, but instead of the jump a dodge is performed)
;IWD : Impact Wall Dodge (a wall dodge boosted by the shield gun)

Moves that include dodging can be performed from standing still or running. Values here list standing dodges first, followed by values for a dodge performed orthogonally to the running direction.

Moves that include walldodging can be performed by jumping upwards without moving horizontally and then dodging away from the wall (listed as first value) or by jumping along the wall and dodging 45° away from it in the same direction as the jump. (listed as second value)

Height differences between standing and moving dodges might be an inaccuracy in the jump stats mutator.

==Jump Without Any Modification ==

The following values have been gathered without any speed/jump modifying additions, i.e. default gravity, no adrenaline combos and no physics-altering mutators.

===Without Shield Gun ===

{| class="wikitable"
|-
! Move !! Height !! Distance !! Notes
|-
|J
| style="text-align: right" |54 UU
| style="text-align: right" |315 UU
|
|-
|D
| style="text-align: right" |19 / 20 UU
| style="text-align: right" |292 / 351 UU
|
|-
|J, DJ
| style="text-align: right" |126 UU
| style="text-align: right" |608 UU
|
|-
|D, DJ
| style="text-align: right" |90 / 91 UU
| style="text-align: right" |742 / 857 UU
|
|-
|J, DJ, WD
| style="text-align: right" |149 / 143 UU
| style="text-align: right" |516 / 965 UU
|
|-
|J, WD, DJ
| style="text-align: right" |150 / 145 UU
| style="text-align: right" |787 / 1047 UU
|
|}

===Shield Gun Jumps ===
; Shield Gun aimed straight down for maximum height
{|
! Move !! Height !! Distance !! Notes
|-
| IJ
| style="text-align: right" |455 UU
| style="text-align: right" |878 UU
|
|-
| ID
| style="text-align: right" |270 / ??? UU
| style="text-align: right" |1051 / ???? UU
|
|-
| IJ, DJ
| style="text-align: right" |513 UU
| style="text-align: right" |1104 UU
|
|-
| ID, DJ
| style="text-align: right" |347 / ??? UU
| style="text-align: right" |1392 / ???? UU
|
|-
| IJ, DJ, WD
| style="text-align: right" |533 / ??? UU
| style="text-align: right" |861 / ???? UU
|
|-
| IJ, WD, DJ
| style="text-align: right" |513 / ??? UU
| style="text-align: right" |1139 / ???? UU
|
|}

; Shield Gun aimed 45° down on ground or at a wall for maximum distance :
{|
! Move !! Height !! Distance !! Notes
|-
| IJ
| style="text-align: right" |302 UU
| style="text-align: right" |1342 UU
|
|-
| ID
| style="text-align: right" |200 / ??? UU
| style="text-align: right" |1302 / ???? UU
|
|-
| IJ, DJ
| style="text-align: right" |422 UU
| style="text-align: right" |1745 UU
|
|-
| ID, DJ
| style="text-align: right" |288 / ??? UU
| style="text-align: right" |1818 / ???? UU
|
|-
| J, IWD, DJ
| style="text-align: right" |307 / ??? UU
| style="text-align: right" |1537 / ???? UU
|
|-
| J, DJ, IWD
| style="text-align: right" |353 / ??? UU
| style="text-align: right" |2004 / ???? UU
|
|}

==With The Speed Combo ==

===Without Shield Gun ===

{| class="wikitable"
|-
! Move !! Height !! Distance !! Notes
|-
|J
| style="text-align: right" |130 UU
| style="text-align: right" |675 UU
|
|-
|D
| style="text-align: right" |21 / 21 UU
| style="text-align: right" |419 / 495 UU
|
|-
|J, DJ
| style="text-align: right" |279 UU
| style="text-align: right" |1228 UU
|
|-
|D, DJ
| style="text-align: right" |170 / 172 UU
| style="text-align: right" |1333 / 1587 UU
|
|-
|J, DJ, WD
| style="text-align: right" |303 / 300 UU
| style="text-align: right" |962 / 1648 UU
|
|-
|J, WD, DJ
| style="text-align: right" |306 / 301 UU
| style="text-align: right" |1504 / 1999 UU
|I don't think I pulled the long one off the best way, yet.
|}

===Shield Gun Jumps ===
; Shield Gun aimed straight down for maximum height :
{|
! Move !! Height !! Distance !! Notes
|-
| IJ
| style="text-align: right" |326 UU
| style="text-align: right" |1048 UU
|
|-
| ID
| style="text-align: right" |258 / ??? UU
| style="text-align: right" |1461 / ???? UU
|
|-
| IJ, DJ
| style="text-align: right" |479 UU
| style="text-align: right" |1571 UU
|
|-
| ID, DJ
| style="text-align: right" |430 / ??? UU
| style="text-align: right" |2241 / ???? UU
|
|-
| IJ, DJ, WD
| style="text-align: right" |507 / ??? UU
| style="text-align: right" |1181 / ???? UU
|
|-
| IJ, WD, DJ
| style="text-align: right" |505 / ??? UU
| style="text-align: right" |1755 / ???? UU
|
|}

; Shield Gun aimed 45° down on ground or at a wall for maximum distance :
{|
! Move !! Height !! Distance !! Notes
|-
| IJ
| style="text-align: right" |461 UU
| style="text-align: right" |2392 UU
|
|-
| ID
| style="text-align: right" |171 / ??? UU
| style="text-align: right" |1642 / ???? UU
|
|-
| IJ, DJ
| style="text-align: right" |451 UU
| style="text-align: right" |2395 UU
|
|-
| ID, DJ
| style="text-align: right" |369 / ??? UU
| style="text-align: right" |2728 / ???? UU
|
|-
| J, IWD, DJ
| style="text-align: right" |419 / ??? UU
| style="text-align: right" |2144 / ???? UU
| Could be done way better.
|-
| J, DJ, IWD
| style="text-align: right" |417 / ??? UU
| style="text-align: right" |2943 / ???? UU
| I gave up while testing this one. (was the last thing to test) Values way over 3000 UU are definately possible here.
|}

==Related Topics ==
* [[Legacy:Movement Metrics (UT)|Movement Metrics (UT)]]
* [[Legacy:Movement Metrics (UT2003)|Movement Metrics (UT2003)]]
* [[Legacy:General Scale And Dimensions|General Scale And Dimensions]]

[[Category:Legacy Mapping|{{PAGENAME}}]]

User talk:UnrealMuskrat

2014-06-20T14:54:03Z

Wormbo: forgot to sign my post

Hello my name is UnrealMuskrat. How may I help you?

:Hi there and welcome to the Unreal Wiki! You may have noticed I reverted some of your edits. I did that because you changed the information on the affected pages to apply only to the UDK, while they were atually meant for all Unreal Engine games or the engine in general. —[[User:Wormbo|Wormbo]] 14:54, 20 June 2014 (UTC)

User talk:UnrealMuskrat

2014-06-20T14:53:41Z

Wormbo: hi!

Category:Applications

2014-06-20T14:51:45Z

Wormbo: reverted because UDK is only one implementation of the Unreal Engine, while this site wants to cover all of them

This [[Project:Categories|category]] contains a list of programs that can be used for Unreal modding.

[[Category:Article categories| {{PAGENAME}}]]

Talk:Unreal Editor overview

2014-06-20T14:49:13Z

Wormbo:

is this page really any different from the Unreal Engine Overview page? It's overall layout is exactly the same, and it covers the same basic materials as the Unreal Engine Overview page. Yours Truly [[User:UnrealMuskrat|UnrealMuskrat]] 20:18, 19 June 2014 (UTC)

:This article is a kind of portal to the Unreal Editor, while the Unreal Engine overview is about the underlying engine. The UnrealEd is just one of many tools, so it deserves its own set of pages. —[[User:Wormbo|Wormbo]] 14:49, 20 June 2014 (UTC)

Category:Mapping tutorials

2014-06-20T14:46:46Z

Wormbo: reverted because this category is not only for UDK

This [[Project:Categories|category]] contains a list of all mapping-related tutorials created on {{SITENAME}} so far.

[[Category:Tutorials| {{PAGENAME}}]]
[[Category:Mapping articles| {{PAGENAME}}]]

Main Page

2014-06-20T14:44:34Z

Wormbo: clarified the meaning of "IRC"

{| cellpadding="0" cellspacing="10px" style="width:100%;"
| id="topic-list" style="vertical-align:top;" |
'''Welcome to the {{SITENAME}}.''' This site's goal is to provide comprehensive documentation of the [[Unreal Editor]], [[UnrealScript]] and all technical aspects of the [[Unreal Engine]].

If you came here as a player and are looking for details about the Unreal series of games, head over to BeyondUnreal's [[Liandri:|Liandri Archives]]. If you are a server administrator looking for information about running servers for Unreal series games, try the [[uadmin:|Unreal Admin Wiki]] instead.

{{ambox|type=serious|text=Please refrain from using an offline reader or similar tools to download the entire Unreal Wiki. These tools put an insane stress on the server and will most likely get you banned immediately. The Unreal Wiki has a very dynamic nature, but if you want to download a recent snapshot, try our downloadable [[Project:Offline Wiki|Offline Wiki]] archive.}}
__NOTOC__ __NOEDITSECTION__
==Content==
The quickest way to find what you're looking for usually is the search box on the left. Otherwise, try one of the topical starting points below. 
Miss the old {{SITENAME}} content? Head over to the [[Legacy:Home Page|old home page]] and start browsing from there, if you want.

===General topics===
* [[Unreal Engine overview]]
* [[:Category:Applications|All applications]]

{|style="width:100%;"
|-valign="top"
|
===Mapping===
* [[Unreal Editor overview]]
* [[Mapping concepts]]
* [[:Category:Mapping tutorials|Mapping tutorials]]
* [[:Category:Mapping tools|Mapping tools]]
* [[:Category:Mapping articles|All mapping articles]]
|
===UnrealScript===
* [[UnrealScript overview]]
* [[:Category:Classes|UnrealScript API]]
* [[:Category:Programming tutorials|UnrealScript tutorials]]
* [[:Category:UnrealScript utils|UnrealScript utils]]
* [[:Category:Programming articles|All programming articles]]
|
===Modeling===
* [[Modeling overview]]
* [[:Category:Modeling tutorials|Modeling tutorials]]
* [[:Category:Modeling articles|All modeling articles]]
|}
===Internet Relay Chat===
The following [[wp:Internet Relay Chat|IRC]] channels may be additional places of interest to get further help. Bring some patience, because despite being a real-time medium, communication over IRC may be slower than you may be used to from instant messengers.
* [irc://irc.globalgamers.net/unrealwiki #UnrealWiki] on GlobalGamers
* [irc://irc.enterthegame.com/unrealscript #UnrealScript] on EnterTheGame
* [irc://irc.enterthegame.com/unrealed #UnrealEd] on EnterTheGame
* [irc://irc.quakenet.org/unrealed #UnrealEd] on Quakenet

As you may notice, there are still a lot of red links, even here on the main page. This is a side effect of our [[Project:MediaWiki conversion|switch]] to the [[wp:MediaWiki|MediaWiki]] engine and we need '''[[Project:Helping out|your help]]''' to get up to speed again.

Still can't find what you were looking for? You can browse through all of the [[:Category:Article categories|articles by category]].

==Community==
The [[Project:Community Portal|Community Portal]] is the general place to find out what's going on and what needs to be done on the {{SITENAME}}.

New to the {{SITENAME}}? This is a community project and you are invited to join by [[Special:Userlogin|registering]]. We've provided some tips on [[Project:Getting started|how to get started]] so you can immediately start contributing.

| style="vertical-align:top;" |
{| class="infobox infobox-pages" id="recent-edits" style="width:300px;float:none;margin-left:auto;"
|-
| style="text-align:center;font-size:smaller;" |''See [[Special:Recentchanges|Recent changes]] for all changes.''
|-
! Recent Updates
|-
|<dpl>
namespace=|UE1|UE2|UE3|Legacy
count=5
ordermethod=lastedit
order=descending
mode=userformat
adduser=true
addeditdate=true
userdateformat=g:ia D, M j
format=<ul>,<li>[[%PAGE%|%TITLE%]] %DATE% - [[Special:Contributions/%USER%|%USER%]],</li>,</ul>
noresultsheader=''None''
</dpl>
|-
! New Pages
|-
|<dpl>
namespace=|UE1|UE2|UE3
count=5
ordermethod=firstedit
order=descending
adduser=true
addeditdate=true
userdateformat=g:ia D, M j
format=<ul>,<li>[[%PAGE%|%TITLE%]] %DATE% - [[Special:Contributions/%USER%|%USER%]],</li>,</ul>
noresultsheader=''None''
</dpl>
|-
! Recent Discussion
|-
|<dpl>
namespace=Talk|UE1_talk|UE2_talk|UE3_talk|Unreal_Wiki_talk|Category_talk|Legacy_talk|Template_talk
count=5
ordermethod=lastedit
order=descending
mode=userformat
adduser=true
addeditdate=true
userdateformat=g:ia D, M j
format=<ul>,<li>[[%PAGE%|%TITLE%]] %DATE% - [[Special:Contributions/%USER%|%USER%]],</li>,</ul>
noresultsheader=''None''
</dpl>
|}
|}

Talk:Main Page

2014-06-20T14:36:52Z

Wormbo: /* IRC? */ IRC = Internet Relay Chat