Hallo, weiß jemand, wie ich ein Entity mache, mit dem ich dann für eine kurze einstellbare Zeit bzw. bis es erneut getriggert wird die Steuerung des Spielers deaktivieren kann? (er soll sich nicht umschauen, bewegen, springen und ducken können).

In welchen Dateien (wo genau) muss ich was ändern.
Wäre auch über Link zu einem Tutorial zum erstellen eigener Entities schon ganz zufrieden, genaue Anleitung wäre mir zwar lieber ;-)

vielleicht hilft das: pPlayer->EnableControl(FALSE);

Wie erstelle ich ein ganz einfaches Entity, das eine Funktion aufruft?
Habe mir mal das Tut unter http://www.thewall.de/coding/index.php?tutorial=1&id=4 durchgelesen, hat jedoch relativ viel drin was ich wohl nicht brauche.
Das Entity soll gar keine Einstellmöglichkeiten bieten, sondern einfach nur eine Funktion aufrufen, wenn es getrigget wird. Wäre für ein kurzes Beispiel (Auszug für fgd-Datei sowie Änderungen am Quellcode) echt dankbar.

Falls es das schon gibt: Ein einfaches Tut über die Grundlagen der Erstellung eigener Entities (fgd + quellcode) wäre natürlich auch ok.

Ich habe es ausprobiert, funktioniert aber leider nicht - oder Fehler in meinem Code (Bin noch neu im HL-Coding). Deshalb hier mein Code:

In meiner fgd-Datei steht folgendes:
@PointClass base(Targetname) color(255 128 0) = player_control : "Player Control"
[
steuerung(choices) : "Steuerung" : 0 =
[
0 : "Computer"
1 : "Spieler"
]
]

Dann hab ich im Projekt für die hl.dll eine cpp-Datei 'player_control' hinzugefügt:
#include "extdll.h"
#include "util.h"
#include "cbase.h"
#include "player.h"
#include "trains.h"
#include "nodes.h"
#include "weapons.h"
#include "soundent.h"
#include "monsters.h"
#include "shake.h"
#include "decals.h"
#include "gamerules.h"
#include "game.h"

class CPlayerControl : public CBaseEntity
{
public:
void KeyValue( KeyValueData *pkvd );
void Spawn( CBasePlayer *pPlayer );
int pc_steuerung;
};

LINK_ENTITY_TO_CLASS( player_control, CPlayerControl );

void CPlayerControl::KeyValue(KeyValueData *pkvd)
{
if (FStrEq(pkvd->szKeyName, "steuerung"))
{
pc_steuerung = atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else CBaseEntity::KeyValue( pkvd );
}

void CPlayerControl :: Spawn( CBasePlayer *pPlayer )
{
pPlayer->EnableControl(pc_steuerung);
}

Beim compilen hat er aber keine Fehler angezeigt.
Was mache ich falsch?

diablecontrol?

edit:
disablecontrol

oder pPlayer->movetype = none oder so, musst halt suchen wo es sonst im code vorkommen

SWCOOPFORCE-TEAM

NEUE HOMEPAGE/SCREENS: SWCOOPFORCE-MOD | Helft mit für Legalisierung!

Ich würde zuerst mal überprüfen, ob das Entity wirklich dann aufgerufen wird, wenn du es willst. Mach doch einfach mal anstatt dem EnableControls ein Quellcode:ALERT( at_console, "EnableControls();\n" ); rein. Falls das dann im richtigen Moment ausgeführt wird, weisst du, dass die Funktion noch falsch ist. Also musst das irgendwie anders machen.
BTW: Wie wärs, wenn du das mit dem EnableControls in der USE-Funktion machen würdest? Wäre doch mal eine gute Idee ;)

Zitat:

void CPlayerControl :: Spawn( CBasePlayer *pPlayer )
{
pPlayer->EnableControl(pc_steuerung);
}

Another1

...relaxing..atm =)
... und Schweiz suckt!

Für was ist die Spawn-Funktion (Constructor?)
Wird die Use-Funktion dann automatisch ausgelöst, wenn das Entity getriggert wird?
Dan ganze soll nachher so ähnlich sein, wie im Intro von Opposing Force (Spieler kann sich nicht ducken, springen, laufen). Drehen kann er zwar noch, sollte er aber bei mir nachher nicht mehr können.

Ich habe meine Code jetzt etwas überarbeitet. Der Spieler kann jetzt schon nicht mehr laufen, springen, ducken. Doch wie kann ich verhindern, dass er sich umschauen kann?
Mein Code sieht jetzt so aus:

#include "extdll.h"
#include "util.h"
#include "cbase.h"
#include "player.h"

class CPlayerControl : public CBaseEntity
{
public:
void KeyValue( KeyValueData *pkvd );
void Use ( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
int steuerung;
};
LINK_ENTITY_TO_CLASS( player_control, CPlayerControl );

void CPlayerControl::KeyValue(KeyValueData *pkvd)
{
if (FStrEq(pkvd->szKeyName, "steuerung"))
{
steuerung = atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else CBaseEntity::KeyValue( pkvd );
}

void CPlayerControl :: Use ( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
((CBasePlayer *)pActivator)->EnableControl(steuerung);
}

PS: Wozu ist eigentlich das save und restore - Zeugs in manchen Dateien?

oh je... :D
ich weiss nicht genau, aber du könntest in CBasePlayer ne Variable "bool m_locked" oder so einfügen, und dann überprüfst du in PreThink(), ob der Player gelocked ist, und dann setzt du pev->angles auf einen festen Wert, am besten merkst du dir die Richtung des Players, bevor du ihn einfrierst.
Das müsste funktionieren.

Das Save- und Restore-Zeugs ist für den Single-Player, wenn du von einer Entity mehr Sachen speichern musst als nur die pev-Daten. D.h. wenn z.B. ein Spieler auf einem Train steht und ihn bedient, muss dieser nach dem Laden (=Restore :D) den Train ja immer noch bedienen, und das musst du extra speichern (war glaub ich nen doofes Beispiel :-)

Ich habe jetzt in player.h folgendes eingefügt: BOOL m_locked;
In meiner player_control.cpp habe ich eine Variable m_viewlock angelegt.
In der Use Funktion habe ich folgendes hinzugefügt:
if (steuerung == 1) m_viewlock = FALSE;
else m_viewlock = TRUE;
((CBasePlayer *)pActivator)->m_locked = m_viewlock;

Was genau und wo in player.cpp muss ich das mit dem pev->angles einfügen?

Ich bin mal nett heute :D

Also ich würde das hier zu CBasePlayer hinzufügen:

BOOL m_locked;
Vector m_lockview;

und dann in CBasePlayer::PreThink(), am besten direkt vor dem Zeug mit den Trains:

if (m_locked)
{
pev->angles = pev->v_angle = m_lockview;
}

Und dann musst du in deiner Entity nur noch beim Einfrieren
{
pPlayer->m_lockview = pPlayer->angles;
pPlayer->m_locked = true;
}
machen.

Ich habe es ausprobiert und bekam eine Fehlermeldung; war schnell behoben in meinem Entity statt pPlayer->angles musste ich wohl pPlayer->pev->angles schreiben. Fehlermeldung bekam ich keine mehr, hat aber trotzdem nicht funktioniert.
Bei env_shake wird doch die view des Players erschüttert, oder? Hat jemand eine Ahnung, wie man es hinbekommen kann das auch die view einer Kamera erschüttert wird? PS: Spielersteuerung deaktivieren war nur eine Abhilfe, aber die view der Kamera selbst zu erschüttern wäre natürlich genial!

ups ja da hab ich das pev vergessen, aber wieso geht das nicht? hmm mal überlegen....

oh ich dussel:

if (m_locked)
{
pev->angles = pev->v_angle = m_lockview;
pev->fixangle = 1;
}

Das bitte noch einfügen.

Vielen Dank hat funtioniert!
Hat vielleicht jemand ne Idee (Lösungsansatz) für mein 2. Problem (eigentlich ja das gleiche, oder wie auch immer *g*). Ich hab mal ein bisschen im SDK rumgesucht. Gehe ich richtig in der Annahme, dass ich da was in der util.cpp im Abschnitt ändern muss?

Quellcode:id UTIL_ScreenShake ( ... )
[...]Hat sowas jemand von euch schonmal gemacht? Wäre für Code sehr dankbar.

Weis niemand wie sowas geht (bei env_shake auch den view einer Kamera erschüttern)? Funktioniert mein Ansatz? Irgendwelche Ideen, Vorschläge oder Anregungen?

Ich weiss nich ob das überhaupt mit Cams geht, aber du könntest in UTIL_ScreenShake überprüfen, ob ein Spieler grad "in" einer Kamera steckt, und dann anstatt
MESSAGE_BEGIN( MSG_ONE, gmsgShake, NULL, pPlayer->edict() );
das hier versuchen:
MESSAGE_BEGIN( MSG_ONE, gmsgShake, NULL, pCam->edict() );

Aber wie gesagt, das kann sein, dass das mit Cams garnicht geht.

Wie bekomme ich in util.cpp einen Pointer auf die aktivierte Kamera? Klingt für euch vielleicht blöd, aber ich hab echt keinen Schimmer.

Ich auch nich, musst du dir wohl bei Aktivierung der Cam nen Pointer auf die Cam merken.

Hab ich mir auch gedacht, habs aber nicht hinbekommen. Könntest du mir vielleicht mal als Hilfe sagen, was in die player.h rein muss (Definition des Pointers)? Wäre echt nett!

Ja da machste die halt ein
CTriggerCamera m_PlayerView;

Und dann setzt du in CTriggerCamera::Use() das Ding auf this und dann wenn die Camera deaktiviert wird halt wieder auf NULL.

Und dann musst du nur noch testen, ob (m_PlayerView != NULL) ist, und wenn ja ist m_PlayerView die Camera-Entity.