TutorialsMX

Tutoriales de Unreal Editor 4

2009-03-26T09:49:00.003-07:00

UnrealScript

Hacer un Lanzallamas

2008-08-04T13:26:00.000-07:00

Este tutorial a modo de ejemplo, muestra el código necesario para crear una arma capaz de quemar a los enemigos. Tendremos en cuenta que es para UT2004.
BurnerProj.ucc

//===============================================
// BurnerProj.
//===============================================

class BurnerProj expands Projectile;

var float HurtTime;
var float LifeTime; //how long it lives

Function Tick(float deltatime)
{
HurtTime+=deltatime;
LifeTime-=deltatime;

if (HurtTime>0.3)
{
//Hurt the target
Base.TakeDamage(Damage,Instigator,Location,Vect(0,0,0),'Burned'); HurtTime=0;
// Basically ever .3 deltatime this hurts some one
}

if ((LifeTime<0)||(Base==None))
{
Destroy(); //When its life is up, it dies
}
}

defaultproperties
{
Damage=5.000000 // How much damage it does
Mesh=LodMesh'UnrealShare.FlameM' // What it looks like
bUnlit=True
}

Si quisieramos que el proyectil fueran granadas de gas venenoso o flechas envenenadas, siempre podremos cambiar el damage type y borrar la mesh que no usemos.

Así que añadimos el siguiente código a el archivo que hemos creado:

simulated function ProcessTouch (Actor Other, Vector HitLocation)
{
local BurnerProj AnOther,FinalBurn;

if ( Other.Isa('Pawn')) // If the targets a pawn(bot, player, monster, etc.)
{
//This makes sure a person is only set on fire once

foreach AllActors(class'BurnerProj',AnOther)
{
If (AnOther.Base==Other)
FinalBurn=AnOther;
}

//If that person not already on fire

If (FinalBurn==None)
{
//Make the fire
FinalBurn=Spawn(class'BurnerProj',Instigator,,Other.Location,Other.Rotation)

//Set if to have a life time of 1(good for flame-thrower, but if you
//are making a incendiary arrow, or so forth, crank it up to something like 5

FinalBurn.LifeTime=1.0;

// Attaches the fire to the target

FinalBurn.SetBase(Other);
}
else
{
// If the target already on fire, make the fire last longer.
FinalBurn.LifeTime+=5.0;
}

}
}

Cómo poner un Placeable Actor propio en el Editor

2008-07-24T04:17:00.000-07:00

Testurizar cabeza de personaje

2008-07-04T20:35:00.001-07:00

Video Tutoriales

2008-07-04T20:29:00.000-07:00

2D / 3D

Hacer la textura de una cara en Photoshop

Técnica para Extraer Data de Packages

2008-07-04T16:10:00.000-07:00

- Crear un package con algo y con algún nombre válido (en mi caso PK_Prueba)

- Cargar completamente el package a exportar (en mi caso COG_Baird)

- Vamos al LOG y escribimos exactamente y sin espacios de más:

obj savepackage file=[nombredelarchivo] package=[package_a_guardar]

En mi caso:

obj savepackage file=PK_Prueba package=COG_Baird

- Con esto se nos habilita el menú en los coocked packages

- Vamos al package que queremos exportar, seleccionamos el asset a duplicar, click derecho y vemos habilitado el menú y picamos en duplicate

- Lo duplicamos en un nuevo package que creamos, en mi caso COG_Baird_copy, no el PK_Prueba, ya que si lo hiciéramos en este, los cambios no se guardarían

- El nuevo package no estará cocinado y podrá ser modificado y guardado

_______________________
por ModderX

Commandos de Consola

2008-07-04T09:02:00.000-07:00

Cheats

Commando Descripción

allammo gives you full ammo

allweapons gives you all weapons

fly you can fly (see also walk and ghost)

ghost you can go through walls, you don't collide with anything (see also walk and fly)

god you'll become invincible

loaded gives you all weapons and full ammo

playersonly pauses game but you can still move around

walk you move normally (see also fly and ghost)

Bot commands

command	Descripción
addbots [count]
killbots

Viewmodes (rendering and performance modes)

command	Descripción
viewmode lit	normal viewmode - you can omit the parameter for this one
viewmode lightcomplexity
viewmode lightingonly
viewmode shadercomplexity
viewmode texturedensity
viewmode unlit
viewmode wireframe

Performance, statistics

command	Descripción
stat engine
stat fps	shows frames-per-second
stat ld	shows all stats (engine+memory+scenerendering) at once
stat memory
stat scenerendering

Show commands

Works similar like turning various flags on/off in the editor.

command	Descripción
show bsp
show collision
show foliage
show particles
show postprocess
show rigidbody
show staticmeshes

Screen and camera commands

command	Descripción
behindview	toggles 3rd person view (you can use optional 1/0 as the parameter)
fov [value]	value is in degrees, default is 90
setres [value]	value is in form “1024x767”

Other commands

command	Descripción
exit	quits the game (the same as quit)
quit	quits the game
shot	takes a screenshot
showhud	toggles hud, handy for level screenshots (see shot)
slomo [value]	1 is normal game speed, <1>1 is faster
switchlevel [mapname]	changes the map - for example `switchlevel dm-sentinel`
switchteam

3DGames TV

2008-07-02T20:48:00.000-07:00

Introducción al UnrealScript

2008-07-02T20:38:00.000-07:00

Objetivo

En este tutorial voy a tratar de hacer una introducción a la programación con el motor Unreal usando el lenguaje de scripting UnrealScript y voy a intentar mostrar una visión general de la estructura básica de clases que usa Unreal

Este tutorial está pensado para todos aquellos que están buscando un punto de partida para empezar a crear mods para el Unreal. También recomiendo encarecidamente leer la "Introducción a UnrealScript" de Tim Sweeney ya que esta introducción está más enfocada a la aplicación práctica del UnrealScript al Unreal y su introducción es más genérica.

Esta introducción no abarca el uso de archivos de cabecera ni otras librerías ya que no están disponibles actualmente para el público en general. Para enviarme comentarios, sugerencias y dudas podéis contactar conmigo a través de ca@planetunreal.com. Gracias a Tim Sweeney, Steven Polge, y el resto del equipo de Epic por hacer un juego tan bueno y a los desarrolladores de Epic por ser tan buenos programadores y responder a preguntas. Sois la leche :-).

Introducción

UnrealScript es un lenguaje pensado exclusivamente para desarrollar contenido para juegos que usen el motor Unreal. Está basado en Java y C++, así que si tienes alguna experiencia en cualquiera de los dos lenguajes o tan solo en C, la curva de aprendizaje será relativamente pequeña, pero si no tienes ninguna experiencia anterior te recomiendo encarecidamente que primero aprendas alguno de esos lenguajes y luego vuelvas al UnrealScript. UnrealScript se adhiere a un estilo de sintaxis común tanto a Java como a C++/C, y comparte con Java bastantes palabras reservadas.

UnrealScript es un lenguaje de programación orientado a objetos (OOP - Object Oriented Programming) lo que significa que está basado en los conceptos de clases y herencias. Es importante hacer notar que UnrealScript no tiene todas las características de un lenguaje de programación más completo como pueda ser Java; principalmente no soporta conceptos como herencias múltiples pero, afortunadamente, ninguna de estas características son necesarias para hacer una modificación completa. Hay muchos tutoriales sobre OOP que te facilitarán la familiarización con este concepto de programar (prueba en Google).

Una características única de UnrealScript que no se puede encontrar ni en Java ni en C++ son los States (estados). Los estados son una característica que te permite definir diferentes implementaciones de funciones dentro de la misma clase (muy parecido a la sobrecarga de funciones en OOP), y generalmente son usadas para programación basada en el tiempo. Por ejemplo, imagina que tienes una clase Player con 3 estados: Walking, Running e Idle. Imagina que quieres que Player dé un salto en el aire si salta mientras está corriendo (Running), y que no quieres que salte mientras está quieto (Idle). Una forma de hacer esto usando estados es definir la función de salto en los estados Running e Idle, y entonces, en el código de estado Running programas que haga un salto, y en la función de salto del código de estado Idle programas que esté quieto. Entonces ahora, cuando el jugador esté corriendo (y por lo tanto, en el estado Running) dará un salto si le da a saltar y no saltará si está quieto. Lo siento si no es un buen ejemplo, pero debería ayudar para ver mejor cómo los estados pueden llegar a ser muy útiles.

Unreal guarda el código UnrealScript en paquetes o packages (opcionalmente junto con texturas, sonidos y modelos) en el directorio UnrealSystem o UnrealTournamentSystem. Para mantener todas tus nuevas clases en un único paquete para que sea más fácil distribuir sólo tienes que especificar el mismo nombre de paquete en el campo Package cuando crees nuevas subclases dentro de Unrealed.

Usando Unrealed para programar en UnrealScript

Dependiendo de la versión del editor que estés usando el navegador de clases del editor podría estar en la parte derecha de la pantalla o accesible via un icono de peón en la parte superior.

Para compilar y guardar los cambios pulsa F7 y luego, al final del árbol elige guardar, busca tu paquete (package) y haz click en Guardar. Unrealed guardará entonces los cambios (compilados o no) en un archivo en el directorio UnrealSystem o UnrealTournamentSystem con el nombre del packagename y la extensión .u (ejemplo: blah.u para el paquete blah.

Estructura de clases de Unreal
Object y Actor

Todo lo que se programa en UnrealScript está derivado desde una clase muy abstracta y básica llamada Object, y desde ahí tenemos muchas clases internas que se relacionan con el motor en sí mismo (principalmente sonidos, gráficos, etc) y mucho más importante, la clase Actor que contiene todo lo que podrías querer modificar para modificaciones parciales. La clase Actor define la mayoría de las variables estándares y funciones que son necesarias para todas las clases y todo el material del juego relacionado con el contenido está contenido en clases derivadas de Actor. Jugadores, armas, inteligencia artificial e incluso el juego en sí mismo está derivado de la clase base Actor. Funciones importantes a recordar en la clase Actor son BeginPlay(), Spawn(), Touch(), Tick() y Destroy().

La función BeginPlay() se llama cada vez que una instancia de esta clase se pone en funcionamiento dentro del juego. Es muy útil inicializar variables importantes y hacer otras acciones en el momento de la creación de la instancia.

La función Spawn() se usa para crear una instancia de una clase y ponerla en juego.

La función Touch() se llama cada vez que un actor se toca con otro actor y es muy útil para causar daño o alterar variables de otro actor.

La función Tick() se llama en cada gametick (instante en el juego), generalmente el mayor número de veces posible, así que la puedes usar para realizar acciones de forma contínua o para chequear ciertas condiciones. NOTA: Ten cuidado de no poner demasiado código en una función Tick() ya que es muy fácil sobrecargar (y ralentizar) el juego y provocar un retardo destacable si hay demasiadas cosas ocurriendo a la vez.

La función Destroy() destruye esta instancia de la clase cuando no quieres que siga en juego.

Pawns

La clase Pawn contiene las clases ScriptedPawn (IA), FlockPawn (IA de insectos y enjambres), PlayerPawn (jugadores) y las clases Bot (relativas a los bots, como es lógico). Básicamente contiene todas las "entidades vivas" de un mapa. La clase Pawn define variables básicas, funciones de movimiento y otras funciones comunes a todos los Pawns. Algunas de las variables que se pueden encontrar en todos los pawns son: Health (Vida), Groundspeed/Airspeed (velocidad en tierra / velocidad en vuelo) y JumpZ (saltos).

PlayerPawn comprende todos los jugadores, es decir, clientes, que están disponibles en el juego. Tiene varias clases hijas, principalmente UnrealIPlayer, Human/Skaarj, y otros jugadores male/female (varón/mujer).

PlayerPawn tiene toda la funcionalidad de los jugadores (movimiento, gestión de entrada -ratón, teclado-) mientras que el resto de las clases hijas contienen las animaciones y los sonidos específicos a los diferentes jugadores.

Playerinput() y PlayerCalcView() son 2 funciones que pueden ser alteradas en tus propias clases para crear efectos muy impresionantes en tus modificaciones. Playerinput() gestiona toda la información de entrada del jugador, llama a las funciones pertinentes y modifica los datos apropiados. PlayerCalvView() gestiona los cálculos del área de visión del jugador y puede ser fácilmente modificado para crear una vista en tercera persona, etc.

En la clase ScriptedPawn encontrarás todo el contenido del juego relativo a IA (la única excepción los FlockPawns). Esta clase define el marco de trabajo necesario para todas las criaturas que puedas encontrar en el juego. La IA usa los estados intensivamente y está basada en la técnica de navegación conocida como pathnoding (nodos de paso). Gracias a dios, Steven Polge es un muy buen programador y ha diseñado una IA muy robusta que puede ser usada para crear nuevas criaturas muy fácilmente sin añadir casi nuevo código, usando variables editables para definir todos los aspectos de la IA. Os recomiendo encarecidamente que leáis el artículo "Unreal Creature Care and Feeding Guide" si queréis hacer modificaciones mayores de la IA o si tan sólo queréis tener un conocimiento más profundo de cómo funciona por dentro la IA.

FlockPawns es un caso especial de IA que da vida a esos maravillosos enjambres de moscas y bancos de peces que no hacen mucho más que resultar agradables de ver. Puedes modificarlos para hacerles un poco más inteligentes si quisieras supongo, pero ya hacen bastante para no ser más que insectos. NOTA: FlockMasterPawns gestiona actualmente la creación de FlockPawns, y deberías trabajar con aquellos en lugar de FlockPawns individuales ya que éstos están programados para autodestruirse si no tienen asociado un FlockMasterPawn.

La clase Bot cuelga directamente de ScriptedPawns ya que sus funciones y objetivos son bastante diferentes del resto de IAs del juego. Si quieres estudiar una clase porque tienes ideas de Bots más realísticos/habilidosos/únicos deberías estudiar la clase Bot. NOTA: los bots todavía mantienen la misma estructura inicial que ScriptedPawns así que la guía de Steven Polge es también válida para entender los bots.

Info

La clase Info es una clase generalizada que comprende todas las clases relacionadas con la información relativa al juego, como las reglas actuales (Deatchmatch vs SinglePlayer vs TeamGame), ZoneInfo que es una clase usada para crear lava, agua o tan solo espacio vacío y PlayerReplicationInfo que contiene información de red especial para los Players. La mayor parte de mi experiencia en programación en la clases Info ha estado relacionada con GameInfo para definir nuevos tipos de juego y variaciones de los clásicos, como Deathmach sólo con ASMD. También es posible crear subclases que dependan de ZoneInfo para crear nuevos tipos de zonas como gases tóxicos de Marte o quizás un caso especializado de agua que refleje los disparos de armas, etc.

Triggers

La clase Trigger gestiona la operación de ascensores, puertas y otros eventos respondiendo a ciertas acciones del juego y llevando a cabo otras acciones, ya sea modificando otros actores, desactivando otros triggers o ambos. Los Triggers son invisibles dentro del juego y generalmente son activados por el contacto, la proximidad o por otro trigger. También se puede llamar a la función Trigger() de otra clase para activar ciertos triggers, por ejemplo, para abrir todas las puertas de un nivel a la vez o algo similar. Se pueden crear subclases de Triggers según creas conveniente.

Effects

La clase Effects cubre todos los efectos especiales de Unreal como las explosivones, los efectos de las armas, etc. Crea subclases de Effects para crear nuevos efectos o para combinar unos ya existentes.

Inventory

La clase Inventory contiene las clases Pickup (Items) y Weapon (Armas). Pickup se refiere a todos los items diferentes de armas que un Pawn puede recoger y usar en el juego, ya sea vida, armadura o munición. Puedes usar la clase Pickup para crear tus propios items únicos en una modificación, como por ejemplo una mina antipersonal. La clase Weapon controla todas las funciones relacionadas con el disparo y la adquisición de armas en una partida. Todas las armas individuales están definidas como subclases de la clase Weapons y controlan las características específicas de las armas, como las animaciones y la creación de efectos de proyectiles y armas. Crea una subclase de Weapons para nuevas armas (suponiendo que ya tengas el modelo y las animaciones) o puedes hacer una subclase de un arma ya existente para usar su modelo. NOTA: Weapons tiene una variable muy importante, bInstantHit. Si esta variable está en Verdadero el arma no creará un proyectil (como un cohete en el caso del lanzacohetes), y en su lugar hará un daño instantáneo a cualquier objetivo que esté en su línea de impacto (como el rifle de francotirador).

El resto

Hay muchas clases que se usan para crear el resto de cosas que ves en Unreal como el HUD para los jugadores, luces, brushes en movimiento, menus o nuevos proyectiles. La experimentación y la simple navegación a través del código te debería ayudar a tener un conocimiento básico de cómo funciona el resto y cómo funciona.

Vectores y Ángulos

Unreal usa el concepto de Vectores y Ángulos para controlar el movimiento y la rotación de los Actores en el universo 3D. un vector es una estructura que contiene 3 componentes: los valores X, Y y Z, donde X es el eje delante/atrás, Y es derecha/izqda y Z es arriba/abajo. Puedes modificar estos valores directamente para alterar la posición de un Actor en el universo usando la función SetLocation() con un nuevo vector para la nueva localización.

La rotación está gestionada por la estructura Angle (Ángulo) que también contiene 3 componentes: Pitch, Yaw y Roll, donde Pitch rota arriba/abajo, Yaw derecha/izqda y Roll hará rodar la cámara como si estuvieras haciendo rodar tu cabeza de derecha a izquierda. Con la función SetRotation() puedes alterar la dirección en la que se encuentra un Actor o convertir la rotación en un vector para alterar la dirección de la velocidad de un Actor, etc.

Si estás en el colegio/universidad y quieres saber más acerca de matemáticas 3d te sugeriría que asistieras a clases de Física y Álgebra Lineal ya que los vectores y matrices son un tema común. También puedes buscar online para tutoriales de matemáticas 3d, sé que QDevels tiene un tutorial 3d así como Weapons of Destruction.

Importante: Este tutorial ha sido traducido por dharana a partir del original publicado en UnrealScript.com.

UT3 Tuto Vehicle - part 5 Coding a Basic Vehicle

2008-06-20T14:55:00.000-07:00

Ok where to start, first we need the correct type of vehicle code, in my case (jetbike) I'll use the manta code, try to pick a vehicle which fits yours eg:- if you have a jeep then use the Scorpian code. So what files did i use

UTVehicle_Manta.uc,UTVehicle_Manta_Content,UTVWeap_MantaGun,UTVehicleFactory_Manta.uc.

The first file is in the UTGame/classes folder the others in the UTGameContent/classes.

First we need to rename the class

do this with all 4 files, the reason I rename the original file where most people extend them is so that i can cut out the parts of code that i don't need. Be careful when editing the files if you see this line native(Vehicle) under the class....extends delete it otherwise the game will crash.

So what do we need to change, well most of it is just connecting the code to our meshes in the default properties like so

and here the materials

next we change the vehcile weapon code to link with our VehicleClass

Next we do the Vehiclefactory

Now that all 4 files have been modified to suit our mesh names we can compile them and then play in game :)

Thought you where finished well no, atm i don't have a vehicle replacement Mutator so to test my jetbike I made myself a small test map and added my vehicle factory, to do this in Ued swtich to the generic browser/actor classes, load your .u file then in NavigationPoint/UTVehicleFactory select your VehicleFactory and place it into your map then do a full build then save the map. Now if every thing has gone right you can play your vehicle in-game

Please remember this is only a very basic set up, to get every thing working properly you may have to tweak a lot of the default properties

UT3 Tuto Vehicle - part 2 art 4 Material Setup par Vehículos

2008-06-20T14:54:00.000-07:00

For the materials we need certain types with the correct names as i'm not 100% if they get called by native code that we can't change, so lets be safe than sorry. names are Blue, Blue_BO, Spawn_Blue and Red, Red_BO, Spawn_Red which are all MatrialInstanceConstant, these are parented to materials in the VH_All/Materials package. Here i'll show you how to do the Blue MIC and you'll have to done the same for the others

Ok in the materials section right click on an open space and select New MaterialIntanceConstan (MIC)

I name this Material MIC_cwjetbike_Blue

First we add the parent Material'VH_All.Materials.M_VH_All_Axon_Base'

Then add your textures into the TextureParameterValue, don't forget to tick the boxes as well

Now for the other MIC's,

For the MIC_cwjetbike_Spawn_Blue we need to parent it to the MaterialInstanceConstant'VH_CWE_Jetbike.Materials.MIC_cwjetbike_Blue'

and set all the varibles show below (copied from the Manta mic)

For the MIC_cwjetbike_Blue_BO we need to parent it to Material'VH_All.Materials.M_VH_Burnout' the rest is the same as above

Bad news time yes we need another material this time its a MaterialIntanceTimeVarying, this is where the real BurnOut takes effect, create it as normal and parent it to you MIC_BO(above)

As you can see there are a lot of values to set (this is the manta version) so for mine I just copied the values for now. The only texture you have to add is the Damage_Mask all the others are automaticaly copied from the MIC.

Ok how do you make a Damage_Mask? Answer not sure, but have a look at the picture below

Here you can see how the colours of the mask act on the vehicle, remember when you make your mask use full colours eg:- red=255, the lightblue is B=255 + G=255. the background colour remains Black. As far as I can tell UT3 uses this mask to display the damage on the vehicle starting with the red area's and moving back to the green, i maybe wrong about this so we'll have to wait for comfermation from Epic

Now we do the same for the Red set.

Hopefully thats all we need so that we can now go and start the coding

UT3 Tuto Vehicle - part 3 Simple AnimTree

2008-06-20T14:52:00.000-07:00

In this section I'll try and explain what i think the correct basic set up for a basic animtree is.

Ok first in the Anims section right click and select New Anim Tree

Ok we gave it a name and got this below, ntoice i've added a PreviewSkelMesh and a PreviewAnimSet

Here we right click on the AnimTree and add SkelControlChain

Just like this

Now to add a few controls to the AnimTree, right click on a free space to get the pop up menu, now scroll down till you get the UTSkelControl_TurretConstrained.

Select the control and edit the values to what you need, here i copied straight from the manta. After that we link each controller to the bone that it appleis to. If you scroll down to the controller section you can change the name of the controller 'ControllerName'

Here we have added a UTSkelControl_Damage, tick the bOnDamageActive box and the bOnDeathActive, here we also add the name of the staticmesh for our dead vehicle in DeathStaticMesh.

Hopefully thats all we need for now.

If you look at the other vehilces you'll see i've left out the MorphTargetSet and its AnimTree controllers, also i've left out the controllers DamageSping which control which damage mesh goes where. I'll come back to this later.

UT3 Tuto Vehicle - part 2 Añadiendo Physics_set

2008-06-20T14:50:00.000-07:00

Ok as you can see i've started my vehicle package VH_CWE_Jetbike by importing 3 textures, 1 skeliton mesh(vehicle), anim 1 anim set. These i've set up as normal in the sub-folders

To create a new Physics Asset we need to select the vehicle mesh and right click, from the list select Create New Physics Asset

by clicking yes each time we end up at this screen which has already made us a simple collision box for our mesh

ok hear we now need a physics material, so in your material secton right click and add a new physics material give it a name.

now click the blue arrow on the PhysicsMaterialProperty line which gives its name automatically and then in MaterialType write Metal. I don't know why but the Manta has it so we'll have it as well. And gets entered Here

Next we add a collision box (yellow arrow) and with the scale tool (red arrow) we scale the box up (gizmo center of the box) you can also move/rotate the boxes via move or rotate tools, remember to hold the mouse over the gizmo to get this to work.

Hopefully thats all we need in this section, if i find more i'll come back and add to it.

UT3 Tuto Vehicle - part 1 Setup&Export

2008-06-20T14:49:00.000-07:00

Part 1 3ds Max set-up and Export

ok let make things clear from the start i'm writing this as i'm learning how to do it, so if it doesn't work for you check back later or post questions at the Epic UT3 forum UT3 Character + Weapon Tutorial . So lets start in max with a simple Jetbike which we will use the Manta code later

First we need to align our mesh to the X-axis, you'll notice the funny objects at the front of the weapons, well their are simple mesh objects which will be our bones when we skin the mesh(don't forget to align them to x-axis aswell). Skinning allows us to add as many bones as we need, for this mesh i'm keeping it really simple eg:- engine + 2 bones for the weapon + 2 bones for the exhausts. Now we can export our first mesh via actorx, at the same time export a 2 frame anim for later use.

You will also need various static meshes to form your damage debris, but at least 1 for the dead vehicle. So export your mesh as an ase file so that we can import it as a staticmesh in UT3-Ed.

Ok thats the basics but i need to learn more about the morph sets and how they work so pop back in a few days to see how far i've got

UT3 Tuto Weapons - part 4 Compiling, Game Testing, Fault Finding

2008-06-20T14:48:00.000-07:00

Ok a quick folder check, your weapon package must be in the unpublished folder tree and in the published folder tree(for testing). Scripts in the Scr folder tree. Now we start the UT3-Ed, you get a message asking if you want to compile your scripts click yes, now wait till its finished if you get any warnings/errors double check your code for typo's (i get this every time). So every thing went well good now copy/move your .u file(mine ut40k.u) from the Unpublished/CookedPC/Script folder to the Published/CookedPC/ folder.

ok the last bit we need to do before testing in game is to edit your package config file (in my case ut40k.ini) which is found in the config folder

You'll notice in the top class i don't have an AmmoClassPath you have to add this your self otherwise you won't have any ammo ;)

Now start UT3 pick Instant Action/Deathmatch/map now click next then mutators, we want to use the Weapon Replacement mutator

now highlight the mutator and go and click configure

Here I've replaced 2 of the standard weapons with mine, nice and easy press accept and play till your hearts content :)

---------------------------------------------------------------------------------------------------------------------------------------------------------

Fault Finding

Ok if things don't look right in game what to do

1. check the log file for any errors ref-ing your weapon eg missing meshes/anims/textures

2. Can't see your weapon in First preson mode - play with the PlayerViewOffset=(X=?,Y=?,Z=?) line in the main weapon file default properties

3. Weapon looks to small - add the line Scale=???? in the mesh section of the default properties or re-scale in your 3d app (sometimes better if the scaling is to much)

I'd like to thank the Guys at the Epic UT3 forum Progamming mainly Bez & Parser for their help in sorting the coding problems i was having :)

UT3 Tuto Weapons - part 3 Coding

2008-06-20T14:47:00.000-07:00

Bueno, el método para crear lo escrito, ha sido copy/paste y ensayo y error. En realidad se tendría que entender perfectamente el código para sacarle el máximo probecho.

Para comenzar, necesitamos algo de código para jugar con él, asi que en el Generic Browser, en la pestaña actors, vamos a file ---> export all. Esto nos debería exportar todos los scripts .../UTGame/ExportedScript, pero si no los exportara, podemos bajar una copia original de los scripts en http://udn.epicgames.com/Files/UT3/Mods/UT3ScriptSource_1.1.rar.

Si no emos compilado nunca un mod, será mejor que nos leamos un poco lo que encontraremos en esta página Mod Authoring de la web de Epic.

Vamos a empezar; para esta arma vamos a necesitar la copia de shockrifle, así que lo primero que necesitaremos será abrir estos 3 archivos:

UTWeap_ShockRifle.uc

UTAttachment_ShockRifle.uc

UTAmmo_ShockRifle.uc

Lo primero será cambiar los nombres de los archivos de las armas, en mi caso he reemplazado ShockRifle por SMLasCannon

Así hallamos encontrado a bajo del todo la linia Name="Default__UTWeap_SMLasCannon" cual debería ser igual que el nombre de la classe.

Bien, estamos usando los scripts que emos exportado asi lo vemos en las propiedades por defecto. Los archivos de epic, para no dar problemas a la hora de compilarse, deben ir así:

como podemos ver abajo el código de las propiedades por defecto para añadir a la mesh de la arma. Copiaremos esta linia y la reemplazaremos en nuestro archivo.

No olvidemos hacer esto para la mesh de pickup (unas linias más abajo) y para los otros archivos.

Aquí cambié los nombres de las mesh por los nombres de las mesh del package del arma (los que les corresponde).

Ahora para la classe Attachment

En las propiedades por defecto necesitamos cambiar algunos nombres para que sean igual que el de nuestro package, primero la skeletalmesh para la vista en 3era persona, después tendremos que cambiar weaponclass a nuestra arma y después el nombre de la classe por defecto (marcada con una flecha en la imagen).

Después hacemos algunos cambios a la classe ammo...

después de esto, es hora de compilar y probar...

UT3 Tuto Weapons - part 2 Configurando en UEd

2008-06-20T14:11:00.000-07:00

Ok, en el UEd, importemos nuestras meshes y texturas de nuestra arma y creemos un material. No olvidemos añadir sockets a las meshes; siempre necesitaremos el socket MuzzleFlashSocket, donde usaremos la codificación del shockrifle añadiendo el socket MuzzleFlashSocket. Recordemos que necesitamos staticmeshes para la munición, la cual requiere que MaterialInstanceConstant esté emparentado con Material'PICKUPS.Materials.M_Pickups_Ammo_Shader_Simple'. Miremos el pickup package si no estamos seguros.

Bien, una vez echo esto, necesitaremos crear un AnimSet. Dentor del Genric Browser, en nuestro package, click derecho y seleccionemos New AnimSet.

Pongámosle el nombre correcto....

Una vez nuestro AnimSet se abrió, importemos nuestro archivo PSA

Cerremos nuestro browser y guardemos nuetro package en el directorio CookedPC/CustomWeapons. Ahora podemos mandar esto a nuestro codificador, o intentarlo nosotros mismos, que es lo que haremos en el próximo capítulo...

UT3 Tuto Wapons - part 1 Setup&Export

2008-06-20T14:00:00.000-07:00

Setup y Export en 3DMAX

Bien, la primera cosa a tener en cuenta en la exportación desde 3DMax a UEd, es la orientación. Vemos en la imagen una armaaliniada a las axis X. También vemos dos objetos tontos (dummies), que actuaran como huesos a la hora de la exportación, los cuales también deben ser alineados con las axis X. Yo usé para este ejemplo una arma del antiguo UT2004, pero funciona perfectamente para UT3, cual es porque el primer dummy es llamado BoneWeapon y el dummy de disparo Bone_Flash. La escala/tamaño de la mesh es importante, para hacerlo exacto, lo que haremos será abrir el UT3_Male.max (aceptando los cambios), borremos todo menos el rocket_launcher (realiniando a X), ponemos nuestra arma encima y la rescalamos al mismo tamaño que el Rocket_launcher.

Ahora tendremos que hacer las animaciones para la arma, dependiendo del tipo de arma y los tipos de ataque, tendra más o menos animaciones. Pero las animaciones base són:

2008-06-16T07:08:00.000-07:00

Image:AlienInterference

Description:

The Image:AlienInterference node creates a interface distortion effect on the players HUD. The strength of the effect is set by using the Amount input port. The higher the value set there, the more the HUD will be distorted. To activate the effect the Enabled port needs to be triggered with 1. The range of this effect is from 0 to 1.

Port Description

bool "Enabled"	This port enables the screen effect.
float "Amount"	Sets the strength of the screen effect.
Outputs
NA

In this example the alien interference effect is activated using the Misc:Start node and the Math:ToBoolean node. The strength of the screen effect is set using a Math:SetNumber node connected to a Amount input port. After three seconds the screen effect is turned off again.

Image:ChromaShift

Description:

The Image: ChromaShift is a screen effect node that shifts the chrominance information of the image by a certain amount. The higher the value input on the Amount port the bigger the shift will be. The node has to be activated using the Enabled port in order to work.

Port Description

bool "Enabled"	This port enables the screen effect.
float "event"	Sets the strength of the screen effect.
string "name"	The string input here defines which entities will get event.
Outputs
NA

In this example the Interpol:Float node is used to fade the chroma shift effect in and out over the duration of one second in an infinite loop.

Image:ColorCorrection

Description:

The Image:ColorCorrection can be used to adjust the color of a scene by inputting values to the various input ports. All ports take float values between -1 and 1 (check limits).

Port Description

bool "Enabled"	This port enables the screen effect.
float "Cyan"	Sets the cyan value.
bool "Magenta"	Sets the magenta value.
bool "Yellow"	Sets the yellow value.
bool "Luminance"	Sets the luminance.
bool "Brightness"	Sets the brightness.
bool "Contrast"	Sets the contrast.
bool "Saturation"	Sets the saturation.
bool "Hue"	Sets the hue.
Outputs
NA

A Interpol:Float node is triggered at with a Misc:Start node and fades the hue value from 0 to 1 over the duration of one second.

Image:DepthOfField

Description:

The Image:DepthOfField node adds a depth of field effect to the screen. Focus range and distance as well as the blur amount can be defined using the nodes input ports.

Port Description

bool "Enabled"	This port enables the screen effect.
bool "EnabledDof"	This port enables the screen effect. (?)
float "FoucsDistance"	This port sets the focus distance.
float "FocusRange"	This port sets the focus range.
float "BlurAmount"	Sets the amount of blur.
Outputs
NA

In this example the Image:DepthOfField node is activated and deactivated when entering and leaving a proximity trigger.

Image:DirectionalBlur

Description:

The Image:DirectionalBlur applies a directional blur effect to the screen. The blur direction is defined using the vec3 input port on the node.

Port Description

bool "Enabled"	This port enables the screen effect.
vec3 "Direction"	This port set the direction of the blur.
Outputs
NA

The directional blur effect is triggered by a Misc:Start node.

Image:DistantRain

Description:

The Image:DistantRain node can be used to create a distant rain effect on the screen. Amount, speed, distance and color can be defined in the node.

Port Description

bool "Enabled"	This port enables the screen effect.
float "Amount"	Defines how dense the rain will be.
float "Speed"	This port sets the speed of the rain effect.
float "DistanceScale"	Sets the distance of the effect.
vec3 "Color"	Defines the rain color.
Outputs
NA

The Image:DistantRain node is enabled on start and deactivated after 10 seconds.

Image:EffectBloodSplats

Description:

The Image:EffectBloodSplats node places blood splats on the screen when used. Type and amount of bloodsplats can be defined using the nodes input ports.

Port Description

bool "Enabled"	This port enables the screen effect.
int "Type"	Defines which type of bloodsplats will be created. (?)
float "Amount"	Sets the amount of blood to be spawned. (?)
bool "Spawn"	Spawns new bloodsplats.
Outputs
NA

Blood splats are spawned when a proximity trigger is entered.

Image:EffectCondensation

Description:

The Image:EffectCondentation node places creates a condensation effect on the screen. The amount and center of the effect can be defined using the input ports of the node.

Port Description

bool "Enabled"	This port enables the screen effect.
float "Amount"	Sets the amount of condensation on the screen.
float "CenterAmount"	Sets the center of the effect on the screen.
Outputs
NA

The condensation screen effect is faded in over three seconds, using a Interpol:Float node to interpolate the amount of condensation.

Image:EffectFrost

Description:

The Image:EffectFrost node simulates a frozen HUD. The amount and the center of the effect on the screen can be adjusted using the input ports of the node.

Port Description

bool "Enabled"	This port enables the screen effect.
float "Amount"	Sets the amount of condensation on the screen.
float "CenterAmount"	Sets the center of the effect on the screen.
Outputs
NA

The frost screen effect is faded in and out when a proximity trigger is entered. The Interpol:Float node is used to fade the amount of screen frost in and out.

Image:EffectWaterDroplets

Description:

The Image:WaterDroplets node simulates water droplets on the HUD. The Amount input is used to set the amount of droplets on the screen.

Port Description

bool "Enabled"	This port enables the screen effect.
float "Amount"	Sets the amount of water droplets on the screen.
Outputs
NA

Water droplets are faded in over four seconds using an Interpol:Float node.

Image:EffectWaterFlow

Description:

The Image:WaterFlow node is used to created splashes of water on the camera. The usage is similar to the Image:WaterDroplets node.

Port Description

bool "Enabled"	This port enables the screen effect.
float "Amount"	Sets the amount of the water flowing on the screen.
Outputs
NA

A proximity trigger starts fading in the amount of water flow on the screen, using a Interpol:Float node.

Image:FilterBlur

Description:

The Image:FilterBlur node applies a blur filter to the screen. Blur type and amount of blur can be set using the input ports of the node.

Port Description

bool "Enabled"	This port enables the screen effect.
int "Type"	Sets the type of blur (?).
float "Amount"	Sets the amount of the blur.
Outputs
NA

A proximity trigger blurs the screen when entered and fades out the blur when left again. Interpol:Float nodes are used together with the Image:FilterBlur node.

Image:FilterGrain

Description:

The Image:FilterGrain node applies a grain effect on the screen depending on the value set in the Amount input port.

Port Description

bool "Enabled"	This port enables the screen effect.
float "Amount"	Sets the amount of grain on the screen.(0-?)
Outputs
NA

The grain effect is applied at start with a streght of 0.2.

Image:FilterRadialBlur

Description:

The Image:FilterRadialBlur node blurs the screen around a defined 2D position on the screen. Amount and radius of the blur effect can be defined using the input ports of the node.

Port Description

bool "Enabled"	This port enables the blur effect.
float "Amount"	Amount of blur.
float "ScreenPosX"	X position of the center of the blur effect on screen.
float " ScreenPosY "	Y position of the center of the blur effect on screen.
float "BlurringRadiust"	Radius of the blur effect around the defined center.
Outputs
NA

The radial blur effect is triggered by a start node with an amount of 0.5.

Image:FilterSharpen

Description:

The Image:FilterSharpen node applies a sharpen filter on the screen. Type and amount of the effect can be set using the input ports of the node.

Port Description

bool "Enabled"	This port enables the sharpen effect.
float "Type"	Type of the sharpen filter.
float "Amount"	Strength of the sharpen filter.
Outputs
NA

The sharpen effect is triggered by a start node with an amount of 1.

Image:RainDrops

Description:

The Image:RainDrops node simulates raindrops on the players HUD. Amount, size and size variation can be defined using the input ports of the node.

Port Description

bool "Enabled"	This port enables the sharpen effect.
float "Amount"	Amount of water droplets.
float "Spawn Time Distance"	Sets the spawn time distance.
float "Size"	Size of the water drops.
float "Size Variation"	Size variation of the water drops.
Outputs
NA

The water drop effect is triggered using a proximity trigger and a Math:ToBoolean node.

Image:VolumetricScattering

Description:

The Image:VolumetricScattering node applies a volumetric scattering effect on the screen.

Port Description

bool "Enabled"	This port enables the sharpen effect.
float "Amount"	Amount of water droplets.
float "Tiling "	Sets the tiling for the effect.
float "Speed"	Sets volumetric scattering animation speed.
color "Color"	Set the color of the volumetric scattering effect.
Outputs
NA

Game Nodes

2008-06-16T06:49:00.000-07:00

Game:ActorGetHealth

Description

This node outputs the health of the target entity as an integer.

In this example the health of the target entity is compared using a Math:Less node to check if the value is below 50.

integer "entityId"	Used when changing the attached entity dynamically. Displays the name of the node.
any "Trigger"	This port triggers the health output port.
Outputs
integer "Health"	This port outputs the health of the target entity.

Game:ActorCheckHealth

Description

The Game:ActorCheckHealth node checks the health of an actor and outputs the result on a Boolean output port.

A health range can be defined using the MinHealth and MaxHealth input ports. The target entity of this class needs to be an actor in order to work. When the node is triggered the health of the target entity is checked and if it is within the defined values true will be output on the output port.

The health of an actor is checked by using the Game:ActorCheckHealth node and checking the Boolean output port using a Math:FromBoolean node. The input to the Math:FromBoolean node will be true if the health of the target entity is between 0 and 50. The Math:FromBoolean node then splits the Boolean input in to outputs to be passed on.

integer "entityId"	Used when changing the attached entity dynamically. Displays the name of the node.
any "Trigger"	The health is checked when this port is triggered.
integer "MaxHealth"	Defines the maximum amount of health to check for.
integer "MinHealth"	Defines the minimum amount of check for.
Outputs
bool "InRange"	True is output on this port if the health of the target entity is within the defined limit.

Game:DamageActor

Description

The Game:DamageActor node is used to damage the AI characters or the player. The target of the node has to be an actor, it does not work with entities that are not based on an actor class. The amount of damage as well of the position where the damage will be applied can be defined.

In this example the Game:ActorGetHealth node is used to get the health of the target entity. The health is divided by two and used as a damage value and trigger for the G ame:DamageActor node .

integer "entityId"	Used when changing the attached entity dynamically. Displays the name of the node.
any "Trigger"	Used to trigger the damage.
integer "Damage"	Defines the amount of damage.
vector "Position"	Defines the amount of damage.
Outputs
NA	-

Game:PlayerStaging

Description

The Game:PlayerStaging node is used to limit the controls of the player

In this example the position output port is used with a Vec3:AddVec3 node to perform a simple vector operation.

integer "entityId"	Used when changing the attached entity dynamically. Displays the name of the node.
any "Trigger"	This port triggers the player staging.
Outputs
vector "Pos"	Position of the entity is output on this port.
vector "Rotate"	Rotation of the entity is output on this port.
vector "Scale"	Scale of the entity is output on this port.
vector "FwdDir"	Direction of the Y axis of the entity is output on this port.
vector "RightDir"	Direction of the X axis of the entity is output on this port.
vector "UpDir"	Direction of the Z axis of the entity is output on this port.

Game:LocalPlayer

Description

The Game:LocalPlayer node is outputs the local player client ID in singleplayer games. It does not work in multiplayer games.

In this example the ID of an entity entering a proximity trigger is compared to the local player ID using the Math:Equal node.

Outputs

integer "entityID" The ID of the local player.

Game:ActorSensor

Description

When enabled the Game:ActorSensor node outputs events on the output ports when the target entity of this node performs certain actions. The node has only two input ports for enabling and disabling it. When enabled the output ports will be triggered whenever a certain action happens. If the outputs are not needed, the node should be disabled to prevent any unnecessary outputs. Each port outputs an entity id or other information that can be used to determine which objects the target entity interacted with.

This example shows how to check if the player entered a specific vehicle. The Game:ActorSensor node is enabled and outputs the vehicle Id when a vehicle is entered. The Math:Equal node compares this Id with the entityId of the entity ‘MyVehicle’ obtained from a Entity:EntityId node.

integer "entityId"	Used when changing the attached entity dynamically. Displays the name of the node.
any "Enable"	This port enables the node when triggered.
any "Disable"	This port disables the node when triggered.
Outputs
integer "EnterVehicle"	The ID of the vehicle the target entity has entered.
integer "ExitVehicle"	The ID of the vehicle the target entity has exited.
integer "SeatChange"	The number of the seat in the vehicle the target entity has switched to.
integer "ItemPickedUp"	The ID of the entity that has been picked up by the target entity.
integer "ItemDropped"	The ID of the entity that has been dropped up by the target entity.
integer "ItemUsed"	The ID of the entity that has been used by the target entity.
integer "NPCGrabbed"	The ID of the entity that has been grabbed by the target entity.
integer " NPCThrown"	The ID of the entity that has been thrown by the target entity.
integer " ObjectGrabbed"	The ID of the entity that has been grabbed by the target entity.
integer " ObjectThrown"	The ID of the entity that has been thrown by the target entity.
integer " StanceChanged"	When the stance of the target entity changes the new stance is output:
	0: Stand
	1: Crouch
	2: Prone
	3: Relaxed
	4: Stealth
	5: Swim
	6: ZeroG
integer "SpecialMove"	When the target entity performs a special move this port will output:
	0: Jump
	1: Suitsprint
	2: Suitjump
integer "OnDeath"	When the target entity dies this port will be triggered.

Game:SetVehicleAltitudeLimit

Description

The Game:SetVehicleAltitudeLimit node set the global limit for how high a vehicles can fly in a level. This limit is absolute, so the height of the terrain needs to be taken into account.

In this example the height limit for flying vehicles is set to 100m using the Game:SetVehicleAltitudeLimit node.

integer "entityId"	Used when changing the attached entity dynamically. Displays the name of the node.
any "SetLimit"	This port sets the new altitude limit for the level.
float "Limit"	This value will be set as the new altitude limit for the level.
Outputs
NA	-

Game:DifficultyLevel

Description

The Game:DifficultyLevel node outputs on one of the output ports depending on which difficulty is currently set.

At the start of the level the Game:DifficultyLevel node is triggered using a Misc:Start node. If the difficulty is set to easy, the enemy ‘MyEnenmy_1’ will be spawned. For each higher difficulty setting up to hard one additional enemy will be spawned.

integer "entityId"	Used when changing the attached entity dynamically. Displays the name of the node.
any "Trigger"	This port triggers the output of difficulty level.
Outputs
any "Easy"	This output port is triggers when the difficulty is set to easy.
any "Normal"	This output port is triggers when the difficulty is set to normal.
any "Hard"	This output port is triggers when the difficulty is set to hard.
any "Delta"	This output port is triggers when the difficulty is set to delta.

Entity Nodes

2008-06-16T06:42:00.000-07:00

Entity:EntityPos

Description

This node handles all position related manipulations of the owner entity. All position information of the target entity can be read from the output ports.

Unlike the Entiy:GetPos node the output ports of this node are triggered whenever one of the target entities properties changes. It is not possible to manually trigger the Entity:EntityPos node.

In this example the position output port is used with a Vec3:AddVec3 node to perform a simple vector operation.

Port Description

integer "entityId"	Used when changing the attached entity dynamically. Displays the name of the node.
vector "pos"	Entity will be set to the position entered here.
vector "rotate"	Entity will be set to the rotation entered here.
vector "scale"	Entity will be scaled to the scale entered here.
Outputs
vector "pos"	Position of the entity is output on this port.
vector "rotate"	Rotation of the entity is output on this port.
vector "scale"	Scale of the entity is output on this port.
vector "fwdDir"	Direction of the Y axis of the entity is output on this port.
vector "rightDir"	Direction of the X axis of the entity is output on this port.
vector "upDir"	Direction of the Z axis of the entity is output on this port.

Entity:EntityInfo

Description

This node outputs the id, name, class and archetype of the target node when triggered. In cases where entity types need to be compared this node is very useful.

In this example the name of the target entity of the Entity:EntityInfo node is compared to a string using a String:Compare.

Port Description

integer "entityId"	Used when changing the attached entity dynamically. Displays the name of the node.
any "Get"	Used to trigger the output ports
Outputs
integer "Id"	Id of the entity is output on this port.
string "Name"	Name of the entity is output on this port.
string "Class"	Class of the entity is output on this port.
string "Archetype"	Archetype class of the entity is output on this port.

Entity:EntityId

Description

The Entiy:EntityId node outputs the entity id of the target entity. The node does not need to be triggered since the entity id never changes.

The entity id is used to define the target of the Movement:MoveEntityTo node in this example.

Port Description

integer "entityId"	Used when changing the attached entity dynamically. Displays the name of the node.
Outputs
vector "Id"	The entity id is output on this port.

Entity:BeamEntity

Description

The Entity:BeamEntity node is used to beam objects instantly to any position in the level. When the Beam port is triggered the target entity is moved to the position input on the Position port.

Additionally rotation and scale can be set using the input ports to match the beamed entity to another entity. In contrary to the Movement:MoveEntityTo this node performs the position change instantly, instead over time.

An entity is beamed to the position of a tag point.

Port Description

integer "entityId"	Used when changing the attached entity dynamically. Displays the name of the node.
any "Beam"	The Beam port start the repositioning of the entity.
vec3 "Position"	The position the the entity will be beamed to.
vec3 "Rotation"	This rotation will be set when the entity is beamed.
vec3 "Scale"	This scale will be set when the entity is beamed.
Outputs
any "Done"	An output on this port is triggered when the entity has been beamed.

Entity:EntitiesInRange

Description

The Entity:EntitiesInRange node takes the positions of two entities and checks if they are in a certain range to each other. Depending on the result of the check the output ports are triggered.

The positions of the player and a tag point are being compared and a positive output is triggered when they are within then range of one meter.

Port Description

integer "entityId"	Used when changing the attached entity dynamically. Displays the name of the node.
any "Trigger"	The Trigger port starts the distance check.
integer "Entity1"	The id of the first entity to be compared is input on this port.
integer "Entity2"	The id of the second entity to be compared is input on this port.
float "Range"	The distance to be checked for.
Outputs
bool "InRange"	This Boolean port outputs true if the entities are in range and false if they are not in range.
any "True"	This output port is triggered if the result of the distance check is true.
any "False"	This output port is triggered if the result of the distance check is f.

Entity:AttachChild

Description

This node attaches another entity to its target entity. The child entity will be linked to the target entity until the link is removed.

The child entity defined in the Child input port is attached to the target entity.

Port Description

integer "entityId"	Used when changing the attached entity dynamically. Displays the name of the node.
any "Attach"
integer "Child"
bool "KeepTransform"
bool "DisablePhysics"
Outputs:
NA	-

Entity:GetPos

Description

The functionality of this node is similar to the Entiy:EntityPos node but instead of triggering the output ports whenever any position information changes it only outputs when triggered to do so. The only input port is the ‘ Get ’ port, which when triggered outputs the according information on all output ports. In situations where a constant update is too expensive the Entiy:GetPos should be used instead of the Entiy:EntityPos node which continuously outputs on all ports when any position value changes.

In this example the position output port is used with a Vec3:AddVec3 node to perform a simple vector operation.

Port Description

integer "entityId"	Used when changing the attached entity dynamically. Displays the name of the node.
any "Get"	Used to trigger all output ports.
Outputs
vector "Pos"	Position of the entity is output on this port.
vector "Rotate"	Rotation of the entity is output on this port.
vector "Scale"	Scale of the entity is output on this port.
vector "FwdDir"	Direction of the Y axis of the entity is output on this port.
vector "RightDir"	Direction of the X axis of the entity is output on this port.
vector "UpDir"	Direction of the Z axis of the entity is output on this port.

Entity:BroadcastEvent

Description

The Entity:BroadcastEvent node is used to send an event to one or more entities. The entities that will receive this event are specified by inputting a string to the name port. Each entity that has the string which is input there as a part of their name will receive the event set in the event port.

In this example the Entity:BroadcastEvent node is used to send a Kill event to all entities which have the string ‘Enemy_’ in their name.

Port Description

integer "entityId"	Used when changing the attached entity dynamically. Displays the name of the node.
any "send"	This port sends out the event to the target entities.
string "event"	The event name is defined here.
string "name"	The string input here defines which entities will get event.
Outputs
NA

Entity:DetachThis

Description

The Entity:DetachThis node is used to detach entities from its parent entity. Usually the Entity:AttachChild node has been used before to link the target entity to another entity. The node has to additional ports to set transform an physics settings. When "KeepTransform" is set, the entity will keep its transformation in world space when detached. When "EnablePhysics" is set, physics will be re-enabled again when the entity is detached.

First "MyEntity_1" is attached to "MyEntity_2" using the Entity:AttachChild node. The ID of the child entity is defined using the Entity:EntityId node. Five seconds later the Entity:DetachThis node is used to detach it again from its parent.

Port Description

integer "entityId"	Used when changing the attached entity dynamically. Displays the name of the node.
any "Detach"	Detaches the target entity from its parent.
bool "KeepTransform"	When checked the entity will keep it transformation.
bool "EnablePhysics"	Re-enabled physic on the entity when detached.
Outputs
NA	-

Tutoriales de SandBox 2.0

2008-06-16T05:47:00.000-07:00

Básicos

Nodos

Unreal Editor Tutorials TV

2008-06-16T05:45:00.001-07:00

Cómo crear un cielo

2008-06-16T05:36:00.000-07:00

Configurar un cielo

Este tutorial es de lo mejor que he visto y es completamente no oficial. Intenta explicar a la comunidad la manera de configurar un cielo. Mira
http://www.crymod.com y http://www.crymod.com/tutorials.php para informarte más.

El autor de todas las herramientas es Crytek www.crytek.com

El Cielo

Se modifica el cielo con CryEngine2. La versión anterior los cielos estaban hechos en skyboxes (cajas de cielos) y se podría decir que nosotros estábamos dentro de esa caja. Por eso, en ocasiones, veías las esquinas de la supuesta caja, de allí viene el termino skyboxes.

Con la nueva versión de Cryengine se han hecho algunos cambios. Hora del día, comienzo de la hora de la misión, etc.
etc. Para completar un cielo puedes añadir nubes. Donde antes veías un dibujo de una nube, ahora te permitirá entrar sobre ellas.

Lo básico

Aunque yo no lo llamaría skybox porque dicho termino todavía es usado en Sandbox2(tm). Para hacer un cielo básico tenemos dos opciones:
1) Puedes elegir un cielo donde no exista ni la mañana ni la noche.
2) Puedes tener un cambio del tiempo (dependiendo del tiempo del día).

Configurando la opción 1: Añadiendo un cielo básico

Asumiendo que sabes dónde se encuentran la opción terrain “terreno” sabrás donde se encuentra la opción sky “cielo”.
- Ve a la Rollup bar (Si no estuviese en pantalla ve a menú View / Show rollup bar)
- Selecciona el Segundo botón
- Clic en Environment
- Pulsa el "..." (Botón Azul)

Esto te abre el editor de material, donde puedes seleccionar uno de los cielos disponibles.
Si no ves nada, ve a Materials/Sky. Elige cualquier otro excepto Materials/Sky/Sky
Cierra esta ventana y después pulsa la fleche de al lado de “…” (Botón Azul). Ahora el cielo aparecerá.
-Haz exactamente lo mismo para Material lowspec.
Ahora tienes un cielo estático. Básicamente en la skybox (caja de cielo) veras un dibujo.

Configurando la opción 2: Añadir un cielo donde la hora de juego influya.

Remarco que esta opción esta activada como preterminada al construir un Nuevo mapa.. Pero saber más no cuesta nada. Primeramente debes asegurarte que en las opciones Sky esta introducido el dato ----> Materials/Sky/Sky.
Si no la eliges, puede, pasar cosas catastróficas, como ver el sol en la noche o la luna al mediodía o cosas así.

Asumiendo que sabes dónde se encuentran la opción terrain “terreno” sabrás donde se encuentra la opción sky “cielo”.
- Ve a la Rollup bar (Si no estuviese en pantalla ve a menú View / Show rollup bar)
- Selecciona el Segundo botón
- Clic en Environment
- Pulsa el "..." (Botón Azul)
Esto te abre el editor de material, donde puedes seleccionar uno de los cielos disponibles.
Si no ves nada, ve a Materials/Sky. Elige Materials/Sky/Sky
Cierra esta ventana y después pulsa la fleche de al lado de “…” (Botón Azul). Ahora el cielo aparecerá.
-Haz exactamente lo mismo para Material lowspec.

Si te preguntas ¿Donde se encuentra el sol?, Probablemente lo tendrás encima de ti.
- Ve a Terrain / Time of Day
- Selecciona en la ventanita (A la esquina inferior izquierda) “Force sky update”
- Mueve la barra de arriba de la ventanita y observa que ocurre

Nota: Si no usas “Force sky update” Puede pasar que veas el sol en mitad de la noche.

Como crear un Mapa Nuevo

2008-06-16T05:32:00.000-07:00

Descripción

El siguiente tutorial te enseñará los pasos para empezar creando un mapa nuevo.

Los mapas en el juego de Crysis están basados en gigantestos mapas reales para crear más realismo.

Creando un nuevo mapa, carpeta y archivo

Selecciona en el menú File New.

Pon el nombre de tu nivel en Level Name box y pulsa OK.

Cuando pulses OK, el editor creará una carpeta en el directorio Leves (donde tienes instalado el juego), en el se creará un archivo de extensión .cry, este archivo contiene gran parte de los objetos e información sobre el mapa.

Añadiendo terreno al mapa

Generando el Terreno

Ahora tenemos el mapa vacio, vamos a añadirle Textura para poder caminar sobre el, vamos a autogenerarlo.

Para generar el terreno, vete a Terrain Edit Terrain.

Posteriormente, vete a Tools Generate Terrain.

Puedes acceder directamente a la ventana de Terreno dandole al Botón de Terreno, por defecto o encontrarás en la barra de herramientas.

Cuando le demos a Generare Terrain, nos saldrá una pantalla con multiples parámetros a modificar, los dejamos por defecto y pulsamos OK.

La ventana de Generate Terrain tiene una serie de parametros que influiran en la forma del mapa cuando lo generemos.

Feature Size: Determina la cantidad de terreno a crear.
Bumpiness/Noise: Determina el grado de bumpiness o deformación de la supercicie. NTT: bumpiness viene a ser como cambios rápidos en la superficie.
Detail: Determina el número de veces que se aplicaran los efectos.
Variation: Colocación aleatoria de las islas.
Blurring: Aplica el número de veces que se aplicará el Filtro para evitar el "ruido"
Sharpness (Exp. Base): Determina la nitidez de la superficie.
Sharpness (Freq. Step): Determina el número de veces que se aplicará el Filtro de Nitidez para la superficie.

Cuando la generación del terreno haya terminado te encontrarás con algo parecido a esto:

Ahora pulsa OK para cerrar esa ventana y dar un paseo en 3D por tu "mapa" ahora con textura.
El mapa ahora está en Gris, para tener una primera impresión con una textura aleatoria aplicada necesitas regenerar la textura de la superficie del terreno.

Generando la textura de la superficie del terreno.

Selecciona Generate surface texture.

En el cuadro que te aparezca, lo dejaremos tal cual, ya que las opciones como High Quality lo que hace esque tarde más tiempo, pero consigue más calidad, si quieres, seleccionalo, depués dale a OK.

Ahora ya tienes tu primera impresión de como será tu mapa con textura aplicada sobre la superficie del mapa.

Después de esto pulsa Ctrl + G y recorre libremente el mapa.

Cómo crear Rios

2008-06-16T05:28:00.000-07:00

Descipción

Este tutorial va dedicado hacia aquellos que desean hacer un rio en el editor SandBox 2 de Crysis. Después de darle la forma deseada al rio y la longitud, vamos a darle la textura y los efectos necesarios para hacerlo más bonito.

También te enseñaremos a darle unas particulas al río para hacerlo lo más real posible.

Preparando el terreno para el río

Colocando "River Entity"

Nos vamos a Objects en la sección de rollup bar, una vez hay, darle click a Misc, y por ultimo, River.

Ahora, pulsa el boton izquierdo del ratón en donde será el primer punto, después hacemos lo mismo en donde será el tercero, y para finalizar, pulsamos el boton izquierdo del ratón dos veces (Doble Click) para finalizar.

No te preocupes por las partes del rio que se quedan enterradas en el terreno, más tarde se solucinará.

Después puedes editar la formar y poner/quitar puntos del rio que colo camos anteriormente, para eso, debeis de pulsar el boton Edit en la sección de Shape Editing section.

Para construir el lecho del río, debemos de configurar el ancho del río a 20 y pulsar el botón Align Height Map button.

Esto ajustará el terreno para el río automaticamente, tanto la forma como la anchura, esto también se podría haber hecho con la herramienta Road tool.

Creando la forma del río

Ahora situa el ancho del río a un valor de 10. Ahora usando Y axis (la flecha amarilla) pasamos a darle la altura del río, la que queramos. y alinearlo, seleccionamos la felcha amarilla con el botón izquierdo del ratón, lo hacercamos hacia nosotros, después, pulsa otra vez el boton [i+Align Height Map button[/i].

Ahora, tendremos la trayectoria del río por el aire, no está rozando el suelo, para que de mejor aspecto, es recomendable editar el terreno del transcurso del río, para ello, recomendamos ver el tutorial de como modificar el terreno.

Creando el aspecto del terreno

Asignando el material.

Asigando el material para el río (por ejemplo Materials/Ocean/river_village) usando el editor de material.

Seleccionar Material asignado en el botón de la parte superior izquierda en el editor de materiales. Para ello nos vamos a Material Editor.

Otros parametros para los rios.

En los parametros del río puedes ajustar el material, puede que despues de eso te den la noticia de que se puede ajustar la velocidad del rio aquí, eso afecta la velocidad con la que los objetos flotaran sobre el río (cajas, barriles, etc), no afectará al aspecto del río.

Ejemplo de parametros para el río.

Una buena configuración sería la siguiente:

Width = 30
BorderWidth = 8
StepSize = 6
ViewDistRatio = 100
TileLength = 4
Depth = 10
Speed = 0.5
FogDensity = 0.5
FogColor = 61,86,91
FogColorMultiplier = 0.1
UScale = 0.05
VScale = 0.2

Resultado

Como modificar el terreno

2008-06-16T05:22:00.000-07:00

Descripción

El siguiente tutorial te da una idea de como se debe modificar el terreno. Un buen modelado en el mapa es una base importante para crear un mapa bueno. Este tutorial pretende aprender lo básico sobre las herramientas de edición.

Modificar el terreno en la tabla

Encima de la barra de la derecha, selecciona "modify"

Esto te abrira opciones de la brocha (si no entendeis a que me refiero con brocha preguntad ).

Hay tres tipos de brochas que puedes usar para editar el terreno:
Aplanar (Flattem), Alisar (Smooth) y Elevar/Bajar (Rise/Lower)

Opciones importantes de la brocha

Se pueden canviar el tamaño de la brocha arrastrando la barra

Como mas muevas la barra, sus efectos seran mayores.

* Flatten Height modifica la medida en que tu terreno se va a aplanar. Manteniendo Ctrl y clicando con el boton izquierdo del ratón procederemos a configurar el valor de "height" del terreno donde has clicado.

* Rise/Lower aumenta o disminuye la medida en que dicha herramienta va a hacer su efecto. manteniendo Ctrl y clicando con el boton izquierdo bajaremos la "heigh" del terreno, eso si tiene un valor postivo en la barra "heigh".

La Brocha de Aplanar "Flatten"

Esta herramienta te permitirá aplanar literalmente una parte del terreno.
Para activar esta opcion debes elegirla en la flehcita de "type":

Despues seleccionamos obviamente, Flatten

Y clicamos con el izquierdo

Para aplanar el terreno primero has de seleccionar su medida "heigh" en el control deslizante de "heigh" que se encuentra en "modify" en "terrain"

Ahora clica en el mapa y desliza el raton manteniendo el clicado, el terreno se aplanara donde este la brocha.

Herramienta de Alisar "Smooth"

Esta herramienta permite hacer mas planos los terrenos y evitar terrenos agudos. Activa el modo Smooth en el mismo lado donde activaste el modo Flatten. Para ponerlo en uso es igual que en Flatten, debemos clikar en el mapa.

Herramienta de Elevar/Bajar "Rise/Lower"

Para configurar el elevado o el bajado del terreno debemos mover la barra deslizante de medida "heigh" Despeus Clica en el terreno al igual que en los dos casos anteriores para poner en marcha la herramienta.

Un núnmero negativo producirá una disminución del terreno.

RESULTADO

SandBox - Como pintar el terreno

2008-06-16T05:15:00.000-07:00

Descripción

Con este tutorial aprenderas todo lo básico a lo que se refiere a crear capas y pintar el terreno. Para pintar el terreno se necesitan varias herramientas.

Preparando las capas

Para abrir el editor de capas ve a "terrain" y "textures

Añadiendo una nueva capa

La ventana siguiente se abrirá

Clicando al icono a la izquierda de la X se creara una nueva capa. Directamente el programa nos dejara editar su nombre por defecto. Deberiamos ponerle un nombre que nos sugiera a que nos servira esa capa.

Añadiendo un material

Despues de crear una nueva capa, als opciones apareceran en la ventana fija al lado del gestor de capas.

LayerID se asiganara por defecto a -1, mejro que nunca toques manualmente el valor que sea.

NOTAS

Una vez creada una nueva capa, seleccionala y ve a EDIT SURFACE TEXTURES, Despues clica en el botoón Add; si te apetece puedes nombrar la nueva creación. ( En este ejemplo que usa el creador del tutorial, pone la palabra arena "sand"

Despues, abre el Material Editor

Ahora selecciona un tipo de terreno de la carpeta "terrain"

Asegurate de seleccionar el terrenoq ue quieres y cierra la ventana, clicas en Pick Selected, asi pondras la seleccion anterior.

Ahora has creado un forma de textura, necesitaras asignarla a la capa, mediante la lista.

Añadiendo una textura

Clica el botón cargar textura.

Te aparecera una lista, selecciona una y abrir "open"

Ahora vayamos al editor general, tendars una nueva textura para usar.

Pintando el terreno

Selecciona Layer Painter en la pestaña Terrain.

Despeus de seleccionarlo, abajo tendars una lista de las posible texturas a usar.

Ahora en configuración de la brocha encontraras dos barras para modificar la brocha.

Radio "radius" te perrmite cambiar la grandura de la brocha.

La barra de dureza "Hardness" te permitira si quieres difuminar o tenr una textura media. El terreno cambiara donde apliques la brocha.

La opción "filter" te permitira asignar un color básico

Selecciona un color en la tabla.

Selecciona su luminosidad que buscas.

Clicas Ok y aparecera el color en la opción "filter"

Ahroa clicando en el modo general del editor veras que donde pase la brocha se pintara de ese color.

Resultado

Como puedes ver, se puede conseguir increibles resultados.

UT3 Char Tuto - Part 5 Codificar nuestro Char

2008-06-15T01:23:00.000-07:00

Cómo customizar la codificación de nuestro char

Ok, así que queremos usar un montón de sets customizados para nuestro char. Cuando hablo de sets customizados, me refiero a cosas como baseMIC's para los materiales o el esqueleto (rigs + animsets) o packs de voces...y todos estos set pueden ser cambiados via código en los archivos de Family Info, la única cosa que no funcionará por el momento, serán las facciones, lo cual Epic sabe y intentara arreglarlo para el próximo patch.

Muy bien, pues vamos a comenzar, primero abramos el UnrealEd y en el generic browser click en Actors y despúes desde el menú click a Export All Scripts.

Ahora dejamos que vaya haciendo, tardará un buen rato, y cuando esté echo miremos donde nos ha dejado los scrpts, probablemente en alguna carpeta parecida a Mis Documentos\My

Games\Unreal Tournament 3\UTGame\ExportedScript.

Y ahora a cambiar código:

I.- Editemos nuestro UTEditor.ini y añadimos debajo de la sección [ModPackages] la linia ModPackages=TheSmiths (TheSmiths será la familia del char)

II.- Tendremos que hacer varios directorios para nuestro código. Ej. Mis Documentos\My Games\Unreal Tournament 3\UTGame\Src\TheSmiths\classes

UTFamilyInfo

UTFamilyInfo_Human

UTFamilyInfo_Ironguard

UTFamilyInfo_Ironguard_Female

Como podemos ver en estos archivos, podemos cambiar cada aspecto de nuestra familia de char seteándolo. Lo que sugiero es que empieces con una simple combinación del archivo Faction y los archivos de male/female, y solo cambiemos esos bits que necesitmeos, tal como muestro aquí:

Como podemos ver, lo único que hemos cambiado es la ID de Family, pero podemos cambiar cualquier cosa de nuestro char pack. Ahora guardemos nuestro archivo en el directorio Src\TheSmiths\classes y reabrimos el UEd y deberiamos poder ver esta pantalla:

Decimos que si para que compile nuestra script. Una vez compilado, volvemos a nuestro directorio Mis Documentos\My Games\Unreal Tournament 3\UTGame\Unpublished\CookedPC\Script y buscamos el archivo TheSmiths.u, que deberemos copiar al directorio Published\CookedPC\Script.

Ahora podemos añadir nuestras partes del char customizando el archivo ini con nuestro nombre UTCustomChar.ini y ponerlos en un directorio etra para los chars customizados. Ej. CookedPC\CustomChars\TheSmiths\UTCustomChar.ini

Asegurémonos de poner al principio +ModFamilies=

UT3 Char Tuto - Part 4

2008-04-14T08:00:00.000-07:00

Ok, es hora de linkar todo el trabajo junto para poder jugar nuestro ersonaje en el juego; primero hagamos una copia de seguridad del archivo ini.

*** El archivo que necesitamos editar es el \Documents and Settings\\Mis Documentos\My Games\Unreal Tournament 3\UTGame\Config\ UTCustomChar. ***

Para mi personaje copié y pegué el char Reaper y le cambie el nombre por el mio y listo.

Ahora tendremos que insertar las linias que definen nuestras meshes; simplemente es copiar y pegar la linia de arriba y después cambiar el nombre de la mesh y el Part ID rojo mencionado antes, aquí es donde el nombre de las ombreras es importante tal y como lo definimos al setearlo en verde...

Una vez tengamos todas las partes definidas, podemos guardar el archivo y arrancar el juego. Notemos que no tube que cambiar la imagen PreviewImageMarkup="" en la linia del char, así, cuando cambiemos el player, solo veremos el nombre nuevo.
Para la sección donde cseleccionamos como irá nuestro carácter, podemos o bien sustituir las meshes o si nos sentimos bravos, podemos cambiar las linias de character en el archivo ini.

Ahora ya podemos jugar con nuestro personaje en el juego...

Encontré el camino para poner el model en el editor sin errores por mapear mal los UVW (y no se tienen que modificar).

Lo único que sucede es: este camino no aloja la customización de char. Voy a descifrar el secreto:

I .- Hacemos un triangulo (mesh) escondido por cada parte. Asignamos ese triangulo al bone más cercano.

II.- Hagamos nueatra mesh entera y riggeemos normalmente. Despúes exportemos la full version sin subdivisiones (yo use 1 material por toda mi mesh).

III.- En el UnrealEd, importamos todos los archivos, cada parte del los triángulos y la full version. Nos aeguramos que lo visible este seteado en la parte de la cabeza.

IV.- Asignamos los sockets a cada parte (Torso, Botas y Brazos) y materiales, despúes seteamos -51 Z offset en el origen y -90º en la rotación offset.

V.- Configuremos nuestro archivo INI para cargar los parámetros que queramos.

VI.- Probemos ahora...

PD: No dije que la mesh total tiene que ser la parte de la cabeza. Los pasos tienen que ser actualizados.

UT3 Char Tuto - Part 3 Mesh Setup

2008-04-13T04:59:00.000-07:00

Bien, importemos ya todas las meshes de nuestro personaje, tengamos en cuenta el nombre de las hombreras, es decir: nombredelamesh_LShoPad01 para la que vaya a la izquierda y nombredelamesh_RShoPad01 para la que vaya a la derecha, de otra manera no nos funcionaría.

Seleccionemos cada mesh por turno, doble click o click derecho / Animset editor, asegurémonos que llamamos a la mesh y en propiedades de SkeletalMesh abrimos abrimos materiales y aplicamos nuestro material MIC. Para estar seguro de que todo se asienta correctamente, debemos cambiar el origen (Origin) de la Z a -51 y el RotOrigin Yaw a -90.

Para más diversión, las meshes deberían tener ranuras extras (extra sockets).

Aquí está la lista de las meshes que necesitan sockets:

brazos:- DualWeaponPoint - b_LeftWeapon , WeaponPoint - b_RightWeapon

torso:- HeadShotGoreSocket - b_Neck

piernas:- L_JB -b_LeftAnkle , R_JB -b_RightAnkle

para hacer esto, vamos al animset editor menu/mesh/socket manager...

Click en el desplegable New Socket y cogemos el bueno y click ok

Ahora le ponemos un nombre al socket

Una vez puestos todos los sockets, podremos continuar editando el archivo ini para customizar nuestro char, pero eso lo veremos en el próximo capítulo...

UT3 CharTuto - Part 2 Setup del Material

2008-04-12T12:15:00.000-07:00

Para empezar necesitaremos al menos 6 texturas: cuerpo y cabeza con sus respectivos diffuse, normal y specular (6 en total y todas de 2048x2048).

Importante grabar nuestro package en el directorio:

\Documents and Settings\\Mis Documentos\My Games\Unreal Tournament 3\UTGame\Unpublished\CookedPC\CustomChars

Desde el Generic Browser importamos nuestras texturas en nuestro packages, en este caso, yo seguí las convenciones de nombres de CH_RTeam_Male sustituyendo mis texturas en el material correcto.

Ahora, con todas las texturas importadas, debemos hacer un nuevo MaterialInstanceConstant, este es el material que aplicaremos a la maya.

Bien, ahora pongámosle un nombre decente a niestro MIC, yo usé la extensión _mic (de esta forma se que textura es cual).

Para hacer que todo esto funcione, necesitamos un parent material, viendo que me estoy basando en Rohin (TwinSouls) buscaremos los materiales de CH_RTeam_Male para los materiales del cuerpo (subrayados). Abriendo esto vemos que es pariente de MI_CH_ALL_TwinSouls_Base este es el material que necesitamos para nuestro material MIC, para seleccionar el archivo base, simplemente clickemos en el magnifing glass.

Con los materiales base seleccionados, click en nuestro material del cuerpo y click en la flcha de al lado derecho de la linia parent. Ahora que tenemos la base parent clasificada, podemos añadir nuestra textura listada abajo.

Importante --> Cuando guardemos el package, debemos guardarlo en el directorio:

\Documents and Settings\\Mis Documentos\My Games\Unreal Tournament 3\UTGame\Unpublished\CookedPC\CustomChars

UT3 CharTuto - Part 1 Setup en el 3DMax

2008-04-12T10:00:00.000-07:00

Para empezar bajamos los personajes oficiales desde aquí. Cargamos el archivo UT3_male.max, aceptamos todos los cambios, click derecho en el viewport y clickamos en lo mostrado. Ahora abrimos la ventanita de diálogo de selección de objetos y seleccionamos la maya que s muestra y la borramos. Esto nos dejará con el esqueleto de base, ahora necesitamos aplicarle el personaje humano. Guardamos el archivo con un único nombre: UT3_human_skeleton.max

Antes de modificar nuestra maya dentro de la sección que le corresponda, es buena idea asegurarse de que los uvs están dentro de las regiones configuradas por Epic.

REGIONES DE LOS UVs PARA LOS PERSONAJES DE UT3

Textura de la Cabeza

head - HeadRegions(0)=(SizeX=2048,SizeY=1024)
eyes+mouth - HeadRegions(1)=(OffsetY=1024,SizeX=256,SizeY=256)
mouth - HeadRegions(2)=(OffsetX=256,OffsetY=1024,SizeX=256,SizeY=256)
neck cut - HeadRegions(3)=(OffsetY=1280,SizeX=256,SizeY=256)
helmet_full - HeadRegions(4)=(OffsetX=1024,OffsetY=1024,SizeX=1024,SizeY=1024)
facemask - HeadRegions(5)=(OffsetX=512,OffsetY=1024,SizeX=512,SizeY=512)
goggles - HeadRegions(6)=(OffsetY=1536,SizeX=512,SizeY=256)
chest Female - HeadRegions(7)=(OffsetX=512,OffsetY=1536,SizeX=512,SizeY=512)
neck - HeadRegions(8)=(OffsetY=1792,SizeX=512,SizeY=256)

Textura del Cuerpo

torso - BodyRegions(0)=(SizeX=1152,SizeY=1024)
legs - BodyRegions(1)=(OffsetY=1024,SizeX=1152,SizeY=1024)
pads - BodyRegions(2)=(OffsetX=1152,SizeX=896,SizeY=384)
arms - BodyRegions(3)=(OffsetX=1152,OffsetY=384,SizeX=896,SizeY=896)
boots - BodyRegions(4)=(OffsetX=1152,OffsetY=1280,SizeX=896,SizeY=768)

Ahora escalamos y ponemos nuestra maya encima del esqueleto, no olbidemos que la maya debe estar dividida en secciones, es decir, las botas por una parte, las hombreras por otra, la cabeza por otra, torso, brazos y piernas... Ahora, aplicadas las modificaciones a cada sección, riggeamos la maya. Importante --> en el modificador de piel (skin modifier) , cuando añadimos huesos, seleccionemos solo los que contengan el prefijo b_ (b_head, ...). Y no olbidemos guardar otra vez.

Muy bien, ahora seleccionamos una sección de nuestra maya y abramos el ActorX exporter, seleccionamos un directorio de salida y le ponemos un nombre a la maya de salida y clickamos en Save Mesh. Importante--> aseguremonos de tener checkeado skin-type, all selected y cull unused dummies en el setup del ActorX.

Hacer un Elevador con Matinee

2008-01-17T05:23:00.000-08:00

Hacemos una habitación básica y ponemos algo que haga de elevador. Ahora necesitamos algún trigger que active el movimiento del mover. Entonces, ponemos un RTriggerVolume al pie del elevador y usaremos el RTrigger Event para decirle al elevador que se empiece a mover. Vamos pues al setup de event en Kismet.

Con el Kismet limpio, click derecho y seleccionamos eventàadd a New Comment. Y lo nominamos como elevador, estiramos la caja del comentario para que podamos meter algunas acciones…

En orden para que el elevador se mueva, necesitamos setearlo en el Matinee. El Matinee es una herramienta visual que escribe los movimientos o los eventos, al igual que una linia de animación. Bien, con el elevador seleccionado, click derecho en el Kismet y seleccionamos New Matinee. Damos doble clic en la ventana del Matinee para entrar en el Matinee editor.

Una vez que tenemos abierto el editor del Matinee, clic derecho en la barra gris de la izkierda y seleccionamos Add New Group, llamado “Elevator”

Click derecho a la pista del “Elevador” y poner Add New Movement Track. La linia gris oscuro que pasa por la ventana del Matinee es la línia de tiempo.

Queremos que el elevador se empiece a mover a la mitad del segundo después de haberse activado, y que llegue al final al 3er segundo, así que clickamos alrededor del segundo 0.5 y pulsamos el botón de keyframe para añadir nuestra primera keyframe. El botón de keyframe es este:

En esta primera frame, vamos a poner el elevador en su primera posición (hasta abajo, donde se posa). Ahora ponemos otra keyframe alrededor de los 3 segundos. Y en ese key, movemos el elevador a la posición de arriba (a la posición final donde tenga que ir). Podemos usar Play, Loop Play o Stop para ver que ocurre con el movimiento que hemos creado.

Ahora el elevador funciona, solo falta que al ponernos encima se active. Existe un camino fácil para hacer esto. Ponemos una keyframe al final del matinee, después añadimos otra keyframe inmediatamente antes de esta. “Posición del elevador de la segunda hasta la ultima keyframe siguiente hacia el elevador en la primera keyframe del matinee.” Justo antes que el Matinee termine, el elevador saltará a la posición inicial. Ahora en el kismet seleccionamos el Matinee y chekeamos “bRewindOnPlay”. Esto reseteara el matinee y hara q una vez haya terminado con la ultima key vuelva a la primera.

por ModderX

PhysX: Rigid Body

2008-01-17T05:11:00.000-08:00

¿Como usar Rigid Body Physics?

Primero cercioremonos de que nuestro objeto está seteado como PHYS_RigidBody. Esto sale por defecto en los RDestructibles (los cuales probablemente deberíamos utilizar para los Rigid Body). Seguramente también nos gustaría checkear bWakeOnLevelStart (que está en la sección RDestructible) si queremos que nuestro objeto comience simulando cuando el mapa empiece en su opuesto cuando sea tocado por algo (probablemente queramos checkear que el objeto no está "at rest" (al resto) del principio del mapa). bWakeOnLevelStart hará que el objeto caiga al suelo si este está puesto a cierta altura.

Algunas cosillas mas

Cuando el objeto explosiona, aplica fuerza a los otro. Si queremos ajustar cuanta fuerza va a aplicar a los otros objetos, editaremos en las propiedades del objeto, sección Destruction. ExplosionImpulseStrength es el valor a cambiar. ExplosionImpulseRadius es el area donde será aplicada la fuerza de impulso.

Cómo usar la Animación

2008-01-17T05:05:00.000-08:00

En el Generic Browser, añadimos un nuevo Physical Material haciendo clic derecho.

Clic derecho en el asset de SkeletalMesh y damos a NewPhysicsAsset aceptando a todo.

Nos sale el editor de físicas. Ajustemos las coordenadas donde tienen que ir.

Usemos nuestro PhysicalMaterial en nuestro muñeco, aplicándoselo en las propiedades en el apartado StaticMesh – Physics

Añadimos nuestro SkeletalMesh al mapa. Clic derecho y busquemos

AllTemplates – Add SkeletalMesh_SkeletalMesh_tupersonaje

Abramos sus propiedades y en AnimSecuenceName, le ponemos el nombre de la secuencia que queramos que saque del PSA importado.

Añadimos nuestro AnimSet en la pestaña de AnimSet.

Añadimos nuestro SkeletalMesh en la pestaña de SkeletalMesh.

Para que las luces sean dinámicas, la deberemos de activar. Dentro de propiedades, en la pestaña SkeletalMeshActor – LightEnviorement – Lighting – bEnable checkeado.

Hacemos un Rebuild.

En SkeletalMeshComponent añadimos nuestro AnimTree tal y como hemos venido haciendo con lo demás.

Añadamos también el PhysicalAsset.

Dentro de Collision marcamos BlockAll.

Ahora en el Generic Browser seleccionamos el Physical_Skeleton asset.

Lo añadimos al nivel Add Actor – AddPhysicalAsset:tu_personaje..

Voila

Insertar una Animación

2008-01-17T04:55:00.000-08:00

Voy a definir los pasos para importar una animación y verla en el juego, presupongo que ya se sabe exportar con ActorX y hacer archivos PSK (para posiciones de reposo) y PSA (para animaciones), y exportar con Collada para hacer una StaticMesh colisionable en formato DAE. Ahí van:

Hacemos un nuevo package (lo podemos llamar como el propio personaje).

Importamos texturas y creamos sus materiales correspondientes.

Importamos nuestro archivo PSK con asume maya coordinates checkeado.

Clic derecho en el Generic Browser y clic en NewAnimSet (lo llamamos personaje_anim).

En el campo SkeletalMesh es donde tiene que ir la nuestra, para que aparezca, la seleccionamos en el Generic Browser, volvemos al AnimSet Ed y clic en el botón con la flechita que hay a la derecha del camp SkeletalMesh para añadirlo.

Ahora importamos nuestro PSA, en el AnimSet Ed, vamos a File e import PSA.

Desde la pestaña Mesh le podemos aplicar el material.

Ahora clic derecho en el Generic Browser y ponemos un AnimTree (llamado personaje_tree)

Importamos a nuestro package el archivo DAE checkeando SkinClusters.

Con el StaticMesh Ed, le aplicamos los materiales y le hacemos una autocollision.

Ahora abrimos el AnimTree y en sus propiedades ponemos nuestro skeletal mesh (previamente seleccionado en el Generic Browser) en PreviewSkeletalMesh y en SocketSkeletalMesh.

En SocketStaticMesh ponemos nuestro DAE importado como StaticMesh.

En el SocketName le ponemos el nombre del personaje.

Ahora abrimos donde pone PreviewAnimSets.

Seleccionamos el Animset del Generis Browser.

Dentro de PreviewAnimSets le damos al botón +.

Clic derecho en el fondo del AnimTree y seleccionamos AnimSecuencePlayer.

Linkamos el nodo Animation con Out de (por ahora) None.

Donde pone AnimSecuence, pondremos el nombre de la secuencia que queremos ver, tal y como guardamos con el ActorX. Ahora en vez de None nos sale el nombre de loa secuencia

Checkeamos bPlaying y bLooping y veremos la animación animada continuamente y lista para ser usada.

Tutoriales de Unreal Editor 4.0

2008-01-17T04:35:00.000-08:00

UnrealScript

Añadir/Jugar con nuestro propio Personaje

2008-01-17T04:19:00.000-08:00

Abramos el editor…

Descheckeamos la caja de arriba que pone "Placeable classes only" y expandimos “Pawn”.

Expandimos "GamePawn" y después "Warpawn", después "Pawn_Infantry" y después "Pawn_COGGear".

Ahora escojemos uno de los soldadoss COG, no importa cual, pero yo escojo Marcus, right click en el y pickamos en la única opción que hay "Create Archtype".

Ponemos el nombre del package.

En el generic tab, encontramos nuestro package donde hay creado el archtype.

Right click en el archetype y seleccionamos "Properties"

Rodamos abajo hasta las propiedades llamadas "Pawn"

Expandimos la parte donde pone "Mesh".

Encontremos la caja llamada skeletalmesh.. y cambiemos eso por nuestro modelo.

Ahora, si cerramos la ventana de propiedades y con el archetype seleccionado, vamos al mapa y añadimos un actor, podremos añadir nuestro archetype, y ahi está, ahi veremos nuestro character en el juego… Pero si lo que queremos es añadir y actualmente juegar con nuestro propio carácter, entonces…..

Click en el modelo de nuestro archetype que hemos puesto en el mapa, y con él seleccionado, abrimos el kismet.

Añadimos nuestro archetype "Add object var using (como le hayamos llamado)"

Ahora add action -> pawn -> Possess pawn

Linkamos la caja pawn target a nuestro achtype object.

Ahora new variable -> player -> Marcus

Linkamos esta variable marcus a target box de possess pawn

Ahora simplemente enganchamos la caja de possess pawn a nuestro evento cual queramos triggear con nuestro carácter cambiado, probablemente cuando el nivel esté cargado o en una acción visible.

Y la última cosa por hacer, es liberar a Marcus con el que comienzamos, clickamos en posess pawn (la “action” que creamos antes) y cheackeamos "bKillOldPawn"

Esta técnica, también se usa para crear armas.

Ahora nos faltaria animar nuestro personaje, linkandolo con cada movimiento. Esto se hace a partir de las animaciones del archivo psa que importamos desde el animset. Después se “ordenan” las animaciones con el animtree y asi llamamos el animtree desde las propiedades de archtype.

Para el animTree se tendría que hacer un tutorial a parte. Lo que se ve por eso es que hay una opción al hacer clic derecho en el animTree, que dice WarAnim_MovementNode, el cual nos da cinco movimientos que ya estan preprogramados y los cuales se pueden modificar a nuestro antojo. El caso es que se pueden lindar a nuestras diferentes animaciones (relacionadas con el tipo de movimiento)

Jason Welsh tiene un ejemplo práctico de cómo se anima el personaje y se le ponen attachments.

http://www.jasonwelsh.com/gow/MyPackage.zip

Aquí, un video demostrativo del resultado de utilizar esta técnica.

Para lograr que las animaciones salgan correctamente, debemos utilizar el mismo esqueleto que el de Marcus o cualquier COG, con exactamente los mismos nombres en los huesos. Dejo dos versiones a vuestra disposición, la de Max (oficial) y la de Maya (retocada por mi):

Esqueleto base en Max 2008

Esqueleto base en Maya 2008

Una vez bien importado al UEd, clickando 2 veces al char importado, nos sale el AnimSet, con el que podremos poner los socket haciend Mesh --> Socket Editor. Es muy importante que los sockets tengan también el mismo nombre y esten linkados correctamente. Dejo la lista de todos los sockets de Marcus y compañía:

b_MF_BackMount_R --------> RightBackMount

b_MF_BackMount_L --------> LeftBackMount

b_MF_Face ------------------> head

b_MF_Weapon_L ------------> Bullet

b_MF_IK_Hand_R -----------> IK_RightHand

b_MF_Thight_R --------------> Holster

b_MF_Pelvis ------------------> Belt1

b_MF_Clavicle_R -------------> RightShoulderCoverDust

b_MF_Clavicle_L -------------> LeftShoulderCoverDust

b_MF_Weapon_R_End -------> RightHand

b_MF_Weapon_L_End -------> LeftHand

b_MF_Spine03 ---------------> HeadShootBloodPS

b_MF_Spine03 ---------------> HeadShootGoreMesh

____________________________

por ModderX

http://modderx.blogspot.com/